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

With no annotations provided, the description bears full responsibility for disclosing behavioral traits. The description lacks details about whether the operation is reversible, what side effects occur (e.g., updating the datasource), any authorization requirements, or the response format. Although there is an output schema, the description does not indicate the nature of the 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 a single sentence, which is concise. However, it lacks structure (e.g., bullet points or sections) that could improve readability for a multi-parameter tool. It is front-loaded with the key action and 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?

Given the tool's complexity (6 parameters, 2 required, no schema descriptions, no annotations), the description is incomplete. It does not explain the return value (though output schema exists), the behavior of the tool, or how parameters interact. The agent would have limited understanding of how to use 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 has 6 parameters with 0% description coverage, meaning the schema provides no descriptions for the parameters. The tool description does not elaborate on any parameters, such as what 'role', 'field_type', or 'default_format' mean. The agent would have to infer meaning from parameter names alone, which 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 ('Add') and the resource ('calculated field') and specifies it is added to a 'datasource'. However, it does not differentiate from sibling tools like 'add_parameter' or 'add_worksheet' which also add entities, but the resource is distinct enough for an AI agent to infer 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?

No guidance is provided on when to use this tool versus alternatives such as 'add_parameter' or 'add_dashboard'. There is no mention of prerequisites, such as needing an existing datasource, 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?

No annotations are provided, so the description must convey behavior. It states the tool creates a dashboard, which implies a write operation. However, it does not disclose what happens to existing dashboards with the same name, whether the operation is reversible, or if it requires specific permissions. 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 sentence of 6 words, which is concise and front-loaded with the main action. However, it is arguably too brief for a tool with 5 parameters and no other documentation, sacrificing clarity for brevity.

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

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

Given the presence of an output schema (which may document return values), the description can focus on behavior. However, with no annotations and 5 parameters, the description should provide more context about parameter roles and usage. It is adequate for a simple tool but incomplete for the complexity of combining worksheets with layout options.

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

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

Schema description coverage is 0%, meaning the description does not explain any parameters beyond their names. The description mentions 'multiple worksheets' but does not clarify that 'worksheet_names' is a list of worksheet names, nor does it explain 'layout' options (e.g., 'vertical' vs 'horizontal'). The 'width' and 'height' parameters have defaults but no semantic context. With 5 parameters and 0% coverage, the description adds insufficient 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 'Create a dashboard combining multiple worksheets' clearly states the verb 'create' and resource 'dashboard', and the purpose of combining worksheets. It distinguishes from siblings like 'add_dashboard_action' and 'add_worksheet' by focusing on dashboard creation, but does not explicitly differentiate from 'add_calculated_field' or 'add_parameter' which have different purposes.

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 vs alternatives. It does not mention prerequisites (e.g., worksheets must already exist) or when not to use it. Siblings like 'add_dashboard_action' suggest adding actions to an existing dashboard, implying this tool is for initial creation, but this is not stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is an 'Add' operation, implying a mutation, but doesn't clarify permissions needed, whether changes are reversible, side effects, or response format. For a tool with 7 parameters and no annotation coverage, this is a significant gap in 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, efficient sentence with zero wasted words. It's appropriately sized and front-loaded, clearly stating the core purpose without unnecessary elaboration.

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 (7 parameters, mutation operation), lack of annotations, and 0% schema description coverage, the description is incomplete. While an output schema exists, the description doesn't compensate for missing behavioral context or parameter semantics, making it inadequate for effective tool use.

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

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

Schema description coverage is 0%, meaning none of the 7 parameters have descriptions in the schema. The tool description adds no information about parameters beyond their names implied by context. It doesn't explain what 'action_type', 'fields', or other parameters mean, leaving semantics entirely 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 'Add an interaction action to a dashboard' clearly states the verb ('Add') and resource ('interaction action to a dashboard'), making the purpose understandable. However, it's somewhat vague about what an 'interaction action' entails and doesn't distinguish this tool from sibling tools like 'add_dashboard' or 'configure_chart', which also modify dashboards. It avoids tautology but lacks specificity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context (e.g., after creating a dashboard), or exclusions. With many sibling tools for dashboard manipulation, this omission leaves the agent without direction on selecting this specific 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?

No annotations are provided, so the description must disclose behavioral traits. It does not mention side effects, permissions needed, or any constraints (e.g., parameter uniqueness). The description is too 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?

Single sentence, concise and front-loaded. No wasted words, but could benefit from additional context without becoming verbose.

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

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

Given complexity (9 params, no output schema info in description), the description is incomplete. It does not explain what 'add' means (insert? replace?), or the impact on existing parameters. An output schema exists but not described.

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% meaning the description provides no parameter info. However, with 9 parameters, the baseline is low. The description adds no semantic meaning beyond the schema, which already has names and defaults. Score 3 because schema has defaults and titles.

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 'Add a parameter to the workbook' clearly states the action (add) and resource (parameter to the workbook). It distinguishes itself from siblings like add_calculated_field and add_dashboard by specifying 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?

No guidance on when to use this tool versus alternatives (e.g., when to add a parameter vs. a calculated field). No prerequisites or context provided about workbook requirements.

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 burden but offers minimal behavioral insight. It states the tool adds a reference band but doesn't disclose whether this is a mutating operation, what permissions are needed, if it's reversible (e.g., via 'undo_last_change'), or how it interacts with existing worksheet elements. Some context is implied (e.g., visual modification), but key behavioral traits are missing.

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

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

The description is a single, efficient sentence that front-loads the core action ('Add a reference band') and specifies the target ('to a worksheet') with clarifying detail ('shaded region'). There is zero wasted verbiage, making it highly concise and well-structured for quick comprehension.

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 8 parameters with 0% schema coverage and no annotations, the description is incomplete—it doesn't address parameters, behavioral nuances, or usage context. However, an output schema exists (per context signals), so return values needn't be explained. The description covers the basic purpose adequately but leaves significant gaps for a tool with many parameters.

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

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

Schema description coverage is 0%, so the description must compensate but adds no parameter information. It doesn't explain what 'axis_field', 'from_value/to_value', 'from_formula/to_formula', 'scope', or 'fill_color' mean or how they affect the band. The agent must rely solely on schema property names, which are somewhat descriptive but lack semantic context.

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

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

The description clearly states the action ('Add a reference band') and the target resource ('to a worksheet'), specifying it creates a 'shaded region'. It distinguishes from siblings like 'add_reference_line' by specifying a band/region rather than a line. However, it doesn't explicitly differentiate from all visualization-adding siblings (e.g., 'add_trend_line'), keeping it at 4 rather than 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'add_reference_line' or 'configure_chart'. There's no mention of prerequisites, typical use cases, or exclusions. The agent must infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries full burden. It states the tool adds a reference line but doesn't disclose behavioral traits such as whether this is a mutating operation, what permissions are needed, how errors are handled, or what the output contains. The description is minimal and lacks critical behavioral context for a tool with 8 parameters.

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, efficient sentence with no wasted words. It's front-loaded with the core action and includes helpful examples. Every part of the sentence earns its place by clarifying the tool's purpose concisely.

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

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

Given the complexity (8 parameters, no annotations, 0% schema coverage) and the presence of an output schema, the description is incomplete. It doesn't explain parameter usage, behavioral implications, or provide context for when to use the tool. The output schema may cover return values, but the description lacks necessary operational details for effective use.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'constant, average, median, etc.', which loosely relates to the 'formula' parameter, but doesn't explain any of the 8 parameters (e.g., 'worksheet_name', 'axis_field', 'value', 'scope'). The description adds minimal meaning beyond the schema, failing to address the coverage gap.

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

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

The description clearly states the action ('Add a reference line') and the target ('to a worksheet'), with examples of line types ('constant, average, median, etc.'). It distinguishes from siblings like 'add_reference_band' or 'add_trend_line' by specifying reference lines, though it doesn't explicitly contrast them. The purpose is specific but could be more differentiated.

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

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

No guidance is provided on when to use this tool versus alternatives like 'add_reference_band' or 'add_trend_line'. The description mentions types of reference lines but doesn't specify contexts or prerequisites for use. Usage is implied only by the tool name and description, with no explicit when/when-not instructions.

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 the action is to 'Add a trend line,' implying a mutation, but doesn't disclose behavioral traits such as permissions required, whether it modifies the worksheet in place, error conditions, or side effects. The description lacks context on what happens to existing trend lines or how the addition integrates with the worksheet.

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, efficient sentence that front-loads the core action and key details (trend line types). There is no wasted verbiage, and it directly communicates the essential information without redundancy.

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

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

Given 5 parameters with 0% schema coverage and no annotations, the description is incomplete—it only partially addresses one parameter ('fit'). However, an output schema exists, so return values needn't be explained. For a mutation tool with multiple parameters, more detail on usage and behavior would improve completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions the types of trend lines (linear, polynomial, log, exp, power), which relates to the 'fit' parameter, but doesn't explain other parameters like 'worksheet_name', 'degree', 'show_confidence_bands', or 'exclude_color'. The description adds some value for 'fit' but leaves most parameters undocumented, resulting in a baseline score.

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 trend line') and the target resource ('to a worksheet'), with specific mention of the types of trend lines available (linear, polynomial, log, exp, power). It distinguishes from siblings like 'add_reference_line' or 'add_reference_band' by specifying trend lines, but doesn't explicitly contrast with them.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing worksheet with data), exclusions, or comparisons to similar tools like 'configure_chart' or 'add_reference_line' for related visualizations.

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 fully disclose behavior. It states that a blank worksheet is added, but does not mention side effects (e.g., whether the worksheet becomes active, how it interacts with existing worksheets, or if it requires save). No annotation contradiction.

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

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

The description is a single, clear sentence with no wasted words. It is appropriately concise for a simple tool.

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

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

Given the tool has one parameter and an output schema (likely returns the worksheet ID or success), the description is minimal. It does not describe the return value or any constraints. For a simple add operation, this is adequate but not complete; the agent may need more context to use 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 has one required parameter ('worksheet_name') with 0% description coverage. The description does not explain what 'worksheet_name' means or any constraints (e.g., uniqueness, length). Since there is only one parameter, the baseline is 4, but the description adds no value beyond the schema, so a 3 is appropriate.

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

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

The description clearly states the action ('Add') and the resource ('a new blank worksheet to the workbook'). It distinguishes from sibling tools like 'clone_worksheet' or 'configure_chart', though it could be more specific about the context (e.g., that it adds to an existing 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 like 'clone_worksheet' or 'add_dashboard'. It does not specify prerequisites (e.g., workbook must be open) or exclusions. The context signals show no annotations, so the description carries the full burden.

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 of behavioral disclosure. It states the tool analyzes a TWB file but doesn't describe what the analysis entails, whether it's read-only or modifies data, what permissions are required, or what the output includes. This leaves significant gaps in understanding the tool's 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, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded with the core action and resource, making it easy 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?

Given the tool has an output schema, the description doesn't need to explain return values. However, with no annotations, 0% schema coverage, and one parameter, the description is minimal and lacks details on behavior, usage context, or parameter semantics. It's adequate for basic understanding but has clear gaps in 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%, with one parameter ('file_path') undocumented in the schema. The description adds no information about this parameter, such as what format the file path should be in, whether it's local or remote, or any constraints. It 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 clearly states the action ('analyze') and target resource ('a TWB file'), specifying it's against 'twilize's declared capabilities'. It distinguishes from siblings like 'validate_workbook' or 'profile_twb_for_migration' by focusing on capability analysis rather than validation or profiling. However, it doesn't explicitly contrast with these alternatives.

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

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

No guidance is provided on when to use this tool versus alternatives like 'validate_workbook', 'profile_twb_for_migration', or 'list_capabilities'. The description implies usage for analyzing TWB files against capabilities but offers no context on prerequisites, exclusions, or specific scenarios where this tool is preferred.

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 'Set a custom color palette,' implying a mutation operation, but doesn't disclose behavioral traits such as whether this affects all charts globally, requires specific permissions, is reversible, or has side effects. The mention of built-in palettes adds some context but is insufficient 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 brief and front-loaded with the main action, followed by examples. It avoids unnecessary words, but could be more structured by separating custom and built-in usage explicitly. Every sentence adds value, though it's slightly terse.

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

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

Given the complexity of a mutation tool with 3 parameters, 0% schema coverage, no annotations, and sibling tools that might overlap, the description is incomplete. It lacks details on when to use, parameter meanings, behavioral effects, and how it integrates with other tools. The presence of an output schema helps but doesn't compensate for these 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 all three parameters. It only indirectly hints at 'palette_name' by listing built-in options and 'colors' by mentioning 'custom,' but doesn't explain the purpose of 'custom_name' or the relationship between parameters. No details on format, constraints, or usage are provided.

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 ('Set a custom color palette') and the resource ('color palette'), making the purpose evident. It distinguishes between custom and built-in palettes by listing examples of built-in ones, though it doesn't explicitly differentiate from sibling tools like 'configure_chart' or 'configure_worksheet_style' that might involve color settings.

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

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

No guidance is provided on when to use this tool versus alternatives. The description mentions built-in palettes but doesn't specify if this tool is for overriding defaults, applying to specific elements, or when to choose custom vs. built-in options. There's no mention of prerequisites or related tools like 'apply_dashboard_theme'.

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 of behavioral disclosure. The description mentions that styling is applied to 'all zones in a dashboard,' which implies a mutation operation affecting multiple components. However, it doesn't disclose critical behavioral traits like whether this operation is reversible, what permissions are required, whether it overwrites existing styling, or what happens if parameters are omitted. For a mutation tool with zero annotation coverage, 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, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a tool with 4 parameters and no annotations, and it's front-loaded with the core purpose. Every word earns its place.

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

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

Given that this is a mutation tool with 4 parameters, 0% schema description coverage, no annotations, and an output schema (which reduces the need to describe return values), the description is incomplete. It lacks behavioral context (e.g., permissions, reversibility), parameter details, and usage guidelines. The presence of an output schema helps, but the description doesn't provide enough information for an agent to use the tool confidently.

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

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

Schema description coverage is 0%, meaning none of the 4 parameters have descriptions in the schema. The description mentions 'background' and 'font,' which loosely correspond to 'background_color' and 'font_family' parameters, but it doesn't explain what 'title_font_size' does or provide any details about parameter formats, constraints, or defaults. The description adds minimal value beyond the parameter names, failing to compensate for the schema gap.

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

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

The description clearly states the tool's purpose: 'Apply uniform styling (background, font) to all zones in a dashboard.' It specifies the action (apply styling), the target (dashboard zones), and the styling aspects (background, font). However, it doesn't explicitly differentiate from sibling tools like 'configure_worksheet_style' or 'apply_color_palette', which prevents a perfect score.

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. There are several sibling tools related to styling and configuration (configure_worksheet_style, apply_color_palette, configure_chart), but the description doesn't mention any of them or specify when this tool is appropriate versus others. It only states what it does, not when 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, the description carries the full burden. It indicates the tool is likely destructive (applying migrations, writing files) and does not mention idempotency or side effects. The description adds some behavioral context ('write a migrated TWB plus reports') but lacks details on error handling or state changes.

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 states the core action. It is front-loaded and contains no filler, but could benefit from slightly more structure (e.g., listing key parameters).

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

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

Given the tool has 5 parameters (3 required) and no annotation support, the description is incomplete. It does not explain return values despite having an output schema, nor does it cover migration scope or overrides. Sibling tools with similar purposes demand clearer differentiation.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'file_path', 'target_source', 'output_path', and 'scope' implicitly via 'workbook migration', but provides no details on 'mapping_overrides'. The description does not explain parameter meaning or expected formats beyond what the schema minimally indicates.

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

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

The description states 'Apply a workbook migration and write a migrated TWB plus reports', which is a clear verb+resource combination. However, it does not differentiate from the sibling 'migrate_twb_guided' or 'preview_twb_migration', leaving ambiguity about when to use this tool versus those.

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 like 'migrate_twb_guided' or 'preview_twb_migration'. No context about prerequisites, typical workflow, or exclusions is given.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does not mention that this tool modifies an existing worksheet (mutation), nor does it discuss side effects, authorization needs, or error conditions. The description is too vague for a tool with 23 parameters.

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, which is concise but underspecified for a complex tool with many parameters. It could be improved by adding brief parameter grouping or key behaviors without becoming overly long.

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

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

Given the tool's high complexity (23 parameters, no schema description coverage), the description is inadequate. It does not explain how chart types are set, what field mappings are expected, or how the output is structured. The existence of an output schema does not relieve the description of providing high-level context.

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

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

Schema description coverage is 0%, meaning the description adds no meaning to any of the 23 parameters. The description merely says 'chart type and field mappings' but does not explain how parameters like 'color', 'filters', or 'axis_fixed_range' map to chart configuration. The description should at least summarize parameter roles.

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 'configure' and the resource 'chart type and field mappings for a worksheet', which distinguishes it from sibling tools like 'configure_dual_axis' or 'configure_worksheet_style'. It specifies what is being configured.

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 like 'configure_chart_recipe' or 'configure_dual_axis'. It does not mention prerequisites (e.g., the worksheet must already exist) 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?

No annotations are provided, so the description carries the full burden. It mentions 'shared recipe registry', implying the chart is configured from a predefined recipe, but does not disclose side effects, permissions, or what happens when auto_ensure_prerequisites is false. It is not contradictory but lacks behavioral detail.

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 conveys the core purpose without extra words. It 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?

Given the tool has 4 parameters (2 required), an output schema, and no annotations, the description is insufficient. It does not explain what 'configure' entails, the role of recipe_args, or the return value. The output schema exists but the description doesn't leverage it to reduce completeness burden.

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 should add meaning. However, it does not describe any parameters. The schema already defines fields like worksheet_name, recipe_name, recipe_args, and auto_ensure_prerequisites, but the description adds no extra semantics beyond the tool's purpose. Baseline 3 applies given the schema is the only source.

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

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

The description states the tool configures a showcase recipe chart via the shared recipe registry, providing a clear verb ('configure') and resource ('showcase recipe chart'). It distinguishes itself from sibling tools like 'configure_chart' and 'configure_dual_axis' by specifying 'through the shared recipe registry', but lacks explicit differentiation from similar recipe-related 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?

No guidance is provided on when to use this tool vs alternatives. Given the sibling tools include 'configure_chart' and many others, the description should clarify use cases or when not to use it. The context of 'showcase recipe' is implied but not explicitly compared.

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 fully disclose behavioral traits. It fails to mention that this tool modifies an existing worksheet, whether it is destructive, requires specific permissions, or how it interacts with other configurations. The description is too brief.

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 only one sentence long, which is concise, but it sacrifices clarity and completeness. It does not front-load key information or explain what 'configure' means. The sentence is too vague to be considered effective.

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 high complexity (29 parameters) and no annotations or parameter descriptions, the description is severely inadequate. It does not explain the tool's effect, return value (output schema exists but not referenced), or how to use it 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 0%, and the description adds no parameter-level information beyond the schema titles. With 29 parameters, the description must compensate, but it does not explain any of them. The baseline of 1 is appropriate, but 2 because the schema titles provide some minimal 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 states 'Configure a dual-axis chart composition' which gives a general sense of the tool's purpose. However, it lacks specificity about what 'configure' entails and does not differentiate from sibling tools like 'configure_chart' or 'configure_worksheet_style'.

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 such as 'configure_chart' or 'configure_worksheet_style'. There is no mention of prerequisites, context, or conditions for appropriate use.

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

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

No annotations provided, so the description carries the full burden. It clearly states that it applies styling, which implies a mutation (not read-only). However, it does not disclose what happens to previous styling, whether changes are reversible, or if it triggers any side effects like re-rendering. The description is adequate but lacks depth.

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?

Single sentence, concise, and front-loaded with the main purpose. However, it could be more precise by listing all categories (e.g., 'pane styles, label formats').

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

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

Given the complexity (21 parameters, 0% schema coverage, no annotations, no output schema explained), the description is too brief. It does not explain return values, the scope of styling, or how to use complex parameters like pane_cell_style or label_formats. A more detailed description is needed for effective tool usage.

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

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

Schema description coverage is 0%, so the description must compensate. It only lists three categories (background color, axis/grid/border visibility) but there are 21 parameters covering many more aspects (e.g., hide_band_color, pane_cell_style, label_formats). The description misses most 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 a specific verb 'apply' and a clear resource 'worksheet-level styling', listing the exact styling aspects (background color, axis/grid/border visibility). This distinguishes it from sibling tools like configure_chart, which deals with chart-level styling, and clone_worksheet, which duplicates a worksheet.

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

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

No guidance on when to use this tool versus alternatives like configure_chart or set_worksheet_caption. It does not mention prerequisites (e.g., the worksheet must exist) or provide any context on when not to use it.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does not state whether the tool modifies existing files, requires specific permissions, or if the creation is reversible. The word 'create' implies a write operation, but no further details are given.

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 that directly states the tool's purpose. It is concise and front-loaded, though it could benefit from additional context.

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

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

Given the presence of an output schema and the relatively simple operation (creation from template), the description provides the core purpose. However, it lacks details on parameter behavior, error conditions, or what happens to existing workbooks. It is adequate but not 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?

The input schema has 2 parameters with 0% description coverage, meaning the description adds no detail beyond the schema. However, the parameter names ('template_path', 'workbook_name') are fairly self-explanatory. The description clarifies that the template is from a TWB/TWBX file, which adds context.

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

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

The description specifies the action ('create a new workbook') and the source material ('from a TWB or TWBX template file'). However, it does not differentiate from siblings like 'generate_workbook_from_run' or 'save_workbook', which could create 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 lacks any guidance on when to use this tool versus alternatives (e.g., 'generate_workbook_from_run' or 'open_workbook'). It does not mention prerequisites, such as whether the template file must exist or be provided via a path.

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 describes the multi-step pipeline and output format (.twbx), which adds useful context. However, it lacks details on permissions, error handling, or performance characteristics (e.g., time/complexity for large files), leaving gaps for a tool with significant functionality.

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 and front-loaded with the core purpose, followed by a concise pipeline overview and detailed parameter explanations. Every sentence earns its place by providing essential information without redundancy, making it efficient for quick understanding.

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

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

For a complex tool with 7 parameters, no annotations, and an output schema, the description is largely complete. It covers the purpose, pipeline, parameters, and return summary. However, it could improve by addressing behavioral aspects like error cases or limitations, given the absence of annotations.

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?

Given 0% schema description coverage, the description compensates fully by explaining all 7 parameters in detail. It provides clear semantics for each parameter, including defaults, options (e.g., theme presets), and examples (rules_yaml), adding significant value beyond the basic schema.

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

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

The description clearly states the tool's purpose with specific verbs ('Build a complete Tableau dashboard') and resources ('from a CSV file'), including the end-to-end pipeline details. It distinguishes itself from sibling tools like 'csv_to_hyper' or 'create_workbook' by emphasizing the comprehensive dashboard creation process.

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 through the pipeline explanation and parameter defaults, suggesting it's for automated dashboard generation from CSV data. However, it doesn't explicitly state when to use this tool versus alternatives like 'hyper_to_dashboard' or 'suggest_charts_for_csv', nor does it mention prerequisites or exclusions.

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

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

With no annotations provided, the description carries full burden and adds valuable behavioral context: it discloses the type inference mechanism, the dependency requirement (tableauhyperapi), and the output format (.hyper file for Tableau). However, it does not mention potential side effects like file overwriting or performance considerations for large files.

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 and front-loaded with the core purpose, followed by implementation details, dependencies, parameter explanations, and return value—all in concise sentences that earn their place without redundancy.

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

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

Given the tool's complexity (file conversion with type inference), no annotations, and an output schema that handles return values, the description is complete: it covers purpose, dependencies, all parameters, and the confirmation output, leaving no gaps for the agent to understand and invoke the tool correctly.

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

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

The description adds significant meaning beyond the input schema, which has 0% description coverage. It clearly explains the purpose of all four parameters (csv_path as source, hyper_path as output, table_name for internal naming, sample_rows for type inference), compensating fully for the schema's lack of documentation.

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

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

The description clearly states the specific action ('Convert a CSV file to a Tableau Hyper extract'), the resource involved (CSV file to .hyper file), and distinguishes it from sibling tools like 'csv_to_dashboard' or 'hyper_to_dashboard' by focusing on file format conversion rather than dashboard creation or inspection.

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 through the mention of Tableau workbooks and type inference, but does not explicitly state when to use this tool versus alternatives like 'csv_to_dashboard' or 'inspect_csv'. It provides a prerequisite ('Requires tableauhyperapi') but lacks explicit guidance on 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?

No annotations are provided, so the description must carry the full burden. It accurately states the tool's behavior (describing one capability) but does not disclose side effects, permissions, or error conditions. The description is honest but minimal.

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

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

The description is a single, efficient sentence with no wasted words. It is front-loaded with the key action and 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?

Given the tool's complexity is low (simple retrieval with 2 parameters and an output schema), the description is mostly adequate. However, the lack of parameter semantics and usage guidance reduces completeness for an agent without external knowledge.

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 explain what 'kind' and 'name' refer to or how to obtain valid values. The description adds no meaning beyond the schema field titles, leaving the agent to guess.

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 a capability and its support tier, using a specific verb ('describe') and resource ('capability'). It distinguishes from sibling tools like 'list_capabilities' by focusing on a single capability, though it does not explicitly contrast them.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., 'list_capabilities'). The description lacks context on prerequisites or appropriate usage scenarios, leaving the agent to infer from the name.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does not mention if the tool is read-only, has side effects, requires authentication, or any constraints. The description only states the purpose but not the 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 sentence, front-loaded with the action, and contains no unnecessary words. It is appropriately concise for a simple tool.

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

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

Given the tool's complexity (one parameter, no annotations, but an output schema exists), the description is too sparse. It does not explain the tool's purpose relative to siblings, the format of the summary, or prerequisites. The output schema may provide return structure, but the description should still set expectations.

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

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

Schema coverage is 0%, meaning the input schema provides no description for the 'file_path' parameter. The description does not explain what 'file_path' should point to (e.g., a TWB file, a specific format). With only one parameter, the description should add context beyond the schema.

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

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

The description states 'Summarize the non-core capability gap of a TWB template', which is a specific verb ('Summarize') and resource ('non-core capability gap of a TWB template'). It is clear and distinct from sibling tools like 'profile_twb_for_migration' or 'analyze_twb'.

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

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

No guidance is provided on when to use this tool versus alternatives like 'profile_twb_for_migration' or 'analyze_twb'. The description does not explain what constitutes a 'non-core capability gap' or in what context this is relevant.

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

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

No annotations are provided, so the description carries full burden. It discloses that the tool saves to a file (a write operation) and includes runtime changes, adding useful behavioral context. However, it doesn't mention permissions needed, error handling, or whether the operation is idempotent, leaving gaps 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 appropriately sized and front-loaded with the core purpose in the first sentence. The Args and Returns sections are structured but slightly verbose; every sentence earns its place by clarifying parameter behavior and output.

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

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

Given no annotations, 0% schema coverage, but an output schema exists, the description is fairly complete. It covers purpose, parameter details, and output summary. However, as a mutation tool (file write), it could better address safety or error scenarios to be 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 description coverage is 0%, so the description must compensate. It fully explains the single parameter 'output_path', including its purpose, default value ('./dashboard_rules.yaml'), and location context ('current working directory'). 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 clearly states the specific action ('Export') and resource ('current active rules'), specifying the output format ('YAML file'). It distinguishes from siblings like 'get_active_rules' (which likely retrieves but doesn't export) and 'reset_rules' (which modifies rather than exports).

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 usage: exporting rules for future sessions or placement with data files. It mentions runtime changes from 'set_rule()', implying this tool captures dynamic state. However, it doesn't explicitly state when NOT to use it or name alternatives among siblings.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It only states 'Generate and save,' which implies file creation but does not mention side effects (e.g., overwrites existing file, requires specific permissions, or what happens on error). No behavioral traits beyond the basic action are disclosed.

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

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

The description is a single sentence, concise and to the point. However, it is too brief, missing essential details. Conciseness is good but at the expense of completeness.

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

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

Given the complexity (3 required params, nested objects, no annotations, output schema present), the description is inadequate. It does not explain what the JSON represents, how the layout_tree should be structured, or what the output contains. The output schema exists but is not referenced in the description.

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 describe any parameters (output_path, layout_tree, ascii_preview). The schema itself has titles but no descriptions. The tool name suggests layout generation, but parameter semantics are entirely absent from the description.

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

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

The description states 'Generate and save a dashboard layout JSON file.' This clearly identifies the verb (generate/save) and resource (dashboard layout JSON file). However, it does not differentiate from sibling tools like 'build_wireframe' or 'configure_chart', which might also involve layout generation. The purpose is clear but lacks sibling distinction.

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. Given many sibling tools (e.g., build_wireframe, configure_chart), explicit usage context is missing. There is no mention of prerequisites, workflow position, 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. It effectively discloses behavioral traits: it's a read-only operation (implied by 'Return'), describes its role in session initialization, and explains how rules affect other tools (validation with errors/warnings). It doesn't detail rate limits or auth needs, but covers core behavior well.

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 front-loaded with the core purpose, followed by usage guidance and return details. Every sentence earns its place: the first states what it does, the second explains when to use it, the third provides context, and the fourth specifies the return format. No wasted words.

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

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

Given the tool's complexity (simple read operation with 0 params), no annotations, but an output schema exists, the description is complete. It covers purpose, usage, behavioral context, and return format, making the output schema sufficient for details without redundancy.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description adds value by explaining why no parameters are needed (it returns all active rules at session start), justifying a score above the baseline of 3 for high schema coverage.

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

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

The description clearly states the tool's purpose with a specific verb ('Return') and resource ('active dashboard creation rules'), distinguishing it from siblings like 'set_rule' or 'reset_rules'. It explicitly mentions what it returns and its role in understanding constraints.

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

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

The description provides explicit guidance on when to use this tool: 'Call this at the start of a session to understand what constraints are enforced.' It also mentions the context of rules engine validation for other tools like 'configure_chart' and 'add_dashboard', offering clear usage context.

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

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

With no annotations provided, the description carries the full burden and does well by detailing the multi-step pipeline behavior (schema inference, chart suggestion, etc.) and output format (.twbx). It mentions default behaviors for parameters but lacks details on error handling, performance, or system requirements.

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

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

The description is well-structured with a purpose statement, pipeline overview, parameter details, and return info. It is appropriately sized but could be slightly more front-loaded; the pipeline details are useful but might be condensed.

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 complex tool with 8 parameters, 0% schema coverage, and no annotations, the description is quite complete—covering purpose, pipeline, parameters, and returns. The presence of an output schema reduces the need to detail return values, but more behavioral context (e.g., error cases) would enhance completeness.

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

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

Given 0% schema description coverage, the description fully compensates by explaining all 8 parameters in the 'Args' section, providing clear semantics for each (e.g., 'max_charts: Maximum number of charts (0 = use rules default)'). This adds significant value beyond the basic schema.

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

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

The description clearly states the tool's purpose with specific verbs ('Build a complete Tableau dashboard') and resources ('from a Hyper extract file'), including the end-to-end pipeline details. It distinguishes itself from sibling tools like 'csv_to_dashboard' or 'mssql_to_dashboard' by specifying the Hyper file input source.

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

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

The description implies usage context through the pipeline explanation and parameter defaults, but does not explicitly state when to use this tool versus alternatives like 'csv_to_dashboard' or 'create_workbook'. No explicit exclusions or prerequisites 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 provided, the description carries full burden. It discloses key behaviors: reading CSV files, inferring column types, classifying columns semantically, and returning a summary. However, it doesn't mention performance characteristics, file size limits, error handling, or whether the operation is read-only (though implied by 'inspect').

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

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

The description is well-structured with purpose statement, parameter explanations, and return description. Every sentence earns its place, though the parameter section could be slightly more concise. It's appropriately sized for a tool with 3 parameters and complex functionality.

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

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

Given the tool's complexity (schema inference with classification), no annotations, but with output schema present, the description is reasonably complete. It explains what the tool does, all parameters, and the return format. Could benefit from more behavioral context about limitations or performance, but covers core functionality adequately.

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 fully. It provides clear semantic explanations for all three parameters: 'csv_path' as file path, 'sample_rows' for type inference sampling, and 'encoding' for file encoding with default value. This adds substantial value 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 clearly states the tool's purpose with specific verbs ('inspect', 'return') and resources ('CSV file', 'inferred schema with column classification'). It distinguishes from siblings like 'profile_csv' by focusing on schema inference rather than data profiling, and from 'csv_to_dashboard' by not creating outputs.

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 for analyzing CSV structure before processing, but doesn't explicitly state when to use this versus alternatives like 'profile_csv' or 'inspect_hyper'. It provides clear prerequisites (CSV file path) but lacks explicit exclusions or comparison to sibling 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 of behavioral disclosure. It does describe what the tool does (reads Hyper file, maps types, classifies columns) and mentions a prerequisite dependency. However, it doesn't disclose important behavioral aspects like error handling, performance characteristics, file size limitations, or what happens with malformed files. The description adds some value but leaves significant gaps in behavioral understanding.

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 and appropriately sized. It starts with a clear purpose statement, provides implementation details in the middle, and ends with parameter and return value explanations. Every sentence earns its place by adding valuable information. The formatting with clear sections (Args, Returns) enhances readability without unnecessary verbosity.

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

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

Given the tool's moderate complexity (file inspection with classification), no annotations, and the presence of an output schema, the description does a good job. It explains what the tool does, its parameters, and mentions the return format. The output schema existence means the description doesn't need to detail return structure. The main gap is lack of error/edge case handling information, but overall it's reasonably complete for the 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?

With 0% schema description coverage, the description must compensate for the lack of parameter documentation in the schema. It successfully explains both parameters: 'hyper_path' as 'Path to the .hyper file' and 'table_name' as 'Specific table to inspect (empty = first table)'. This provides clear semantic meaning beyond the bare schema. The only minor gap is not explaining path format expectations (absolute vs relative).

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

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

The description clearly states the tool's purpose with specific verbs ('inspect', 'read', 'map', 'classify', 'return') and resources ('Hyper extract file', 'schema with column classification'). It distinguishes itself from sibling tools like 'inspect_csv' by focusing specifically on Hyper files rather than CSV files, providing clear differentiation.

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

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

The description provides clear context about when to use this tool: for inspecting Hyper files to get schema information with column classification. It mentions a prerequisite ('Requires tableauhyperapi') which is helpful guidance. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the many sibling tools, though 'inspect_csv' is an obvious alternative for CSV files.

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

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

No annotations provided, so description carries burden. It discloses it inspects only the first sheet of Excel, but does not mention any side effects or permissions. With no annotations, this is adequate but minimal.

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

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

Single sentence, 10 words, no filler. Front-loaded with verb and resource. Every word earns its place.

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

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

Given only 1 parameter, no annotations, but with an output schema (which presumably explains return value), the description is nearly complete. Could add that it returns field names and types, but output schema likely covers that.

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

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

Schema coverage is 0%, yet description adds no meaning to the 'target_source' parameter. The description only mentions 'target Excel datasource' but does not explain what 'target_source' is or how to specify 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?

Description states verb 'inspect' and resource 'first-sheet schema of a target Excel datasource'. It clearly distinguishes from siblings like 'intake_datasource_schema' by specifying Excel and first-sheet 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?

No explicit when-to-use or when-not-to-use guidance. However, from context it's implied to inspect schema before using other datasource tools. No alternatives 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'List' but does not specify what the output includes (e.g., format, structure), whether it's a read-only operation, or any constraints like rate limits. This leaves significant gaps in understanding the tool's 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, clear sentence with no wasted words, making it highly concise and front-loaded. It efficiently conveys the core purpose without unnecessary elaboration.

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

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

Given the tool has 0 parameters, 100% schema coverage, and an output schema exists, the description is minimally adequate. However, it lacks details on behavioral aspects like output format or usage context, which could be helpful despite the structured data, making it only partially 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 tool has 0 parameters with 100% schema description coverage, so the schema fully documents the inputs. The description does not add parameter details, which is acceptable here as there are no parameters to explain, aligning with the baseline for zero 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 ('List') and the resource ('twilize's declared capability boundary'), making the purpose understandable. However, it does not explicitly differentiate this tool from its siblings like 'describe_capability' or other list tools, which slightly limits its clarity in context.

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 'describe_capability' or other listing tools in the sibling set. It lacks context about prerequisites, timing, or exclusions, leaving usage ambiguous.

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 describes the tool as listing dashboards and zones, implying a read-only operation, which is reasonable but lacks details on side effects or access requirements.

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, clear sentence with no extraneous information. 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?

The tool is simple with zero parameters and an output schema exists (not shown). The description is sufficient given the simplicity, though it could mention that it operates on the currently open workbook.

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

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

Schema coverage is 100% with zero parameters, so the description does not need to add parameter info. It correctly states the scope (current workbook) which adds context beyond the empty 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 dashboards and their worksheet zones in the current workbook, with a specific verb and resource. However, it does not differentiate from siblings like 'add_dashboard' or 'list_worksheets'.

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

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

No guidance on when to use this tool versus alternatives (e.g., 'add_dashboard' or 'list_worksheets'). The context of 'current workbook' is implied but not 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?

No annotations provided, so description carries the burden. It states the tool 'lists' fields, implying a read-only operation with no side effects. However, it does not clarify behavior like caching, pagination, or what 'available' means exactly (e.g., include hidden fields?). The description is minimally adequate but lacks depth.

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 is concise and front-loaded with the key action. Every word earns its place. No wasted text.

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

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

Given no parameters, presence of output schema, and low complexity, the description is nearly complete. It identifies the resource and scope. It could optionally mention that the output includes field names and types, but the output schema presumably covers that. Slight lack of detail on what 'available' means, but adequate for a zero-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?

The input schema has zero parameters, so the description does not need to add parameter details. The description correctly implies no configuration is needed. With 100% schema coverage (trivially), a baseline of 3 applies, but the description adds value by specifying the source ('current workbook datasource').

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 all available fields in the current workbook datasource. It specifies the resource ('fields') and scope ('current workbook datasource'). While it distinguishes from sibling tools like 'add_calculated_field' and 'remove_calculated_field', it does not explicitly differentiate from potential field-related 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?

The description implies usage before other actions that require knowledge of available fields (e.g., adding calculated fields). However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It adds some behavioral context by describing templates as 'user-editable YAML files' and listing components like 'layout zones' and 'suitability criteria', which helps understand the data structure. However, it lacks details on permissions, rate limits, or error handling, leaving gaps for a tool with no annotation support.

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 and concise, with three short paragraphs that efficiently cover purpose, template details, and return format. Each sentence adds meaningful information without redundancy, making it easy to scan and understand 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?

Given the tool's simplicity (0 parameters, output schema exists), the description is reasonably complete. It explains the resource (templates), their format (YAML files), key attributes, and the return type. However, with no annotations, it could benefit from more behavioral details like data freshness or access constraints to fully compensate.

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 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately avoids discussing parameters, focusing instead on the tool's output and context. It adds value by explaining what templates are and what the listing includes, compensating for the lack of parameters.

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

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

The description clearly states the tool's purpose: 'List all templates in the gallery with suitability rules.' It specifies the verb ('List'), resource ('templates in the gallery'), and scope ('with suitability rules'). However, it doesn't explicitly differentiate from sibling tools like 'list_dashboards' or 'list_worksheets' beyond the resource type, missing full sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions what the tool does but offers no context about prerequisites, timing, or comparisons with sibling tools like 'recommend_template' or 'diff_template_gap'. This lack of usage context leaves the agent without clear direction.

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

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

The description states it lists 'names', which is a non-destructive read operation. Since no annotations are provided, the description carries the full burden. It clearly indicates no side effects, though it doesn't mention what happens if the workbook is empty or if there are many worksheets.

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 5 words, perfectly concise and front-loaded. Every word is necessary and 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 the tool's simplicity (no parameters, no output schema needed since output is presumably list of strings), the description is complete. It tells the agent exactly what to expect.

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

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

The input schema has no parameters, so there is nothing to explain. The description adds no parameter semantics, but this is acceptable since there are none. Baseline 3 applies.

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

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

The description clearly states it lists worksheet names in the current workbook, using a specific verb ('list') and resource ('worksheet names'). It is distinct from siblings like list_dashboards, list_fields, and add_worksheet, which have different purposes.

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 you need to know worksheet names, and it is clearly a read-only operation. However, it does not explicitly state when not to use it or compare to alternatives like list_fields or list_dashboards, which might be relevant if the agent needs other information.

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

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

The description discloses a key behavioral trait: it pauses for warning confirmation. This is beyond what annotations provide (none). However, it does not mention side effects, required permissions, or what happens after confirmation. The output schema is present but not referenced.

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 very short (one sentence, 13 words) and front-loaded with the primary action. It is concise, though it could benefit from a bit more detail without becoming verbose.

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

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

Given the tool has 6 parameters (2 required) and an output schema, the description lacks necessary context for an agent to use it correctly. It does not explain the migration workflow, what warnings trigger pauses, or how to handle confirmation. Sibling tools like 'apply_twb_migration' and 'preview_twb_migration' suggest alternatives, but no comparison is made.

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 additional meaning for any of the 6 parameters. The description does not explain 'mapping_overrides', 'scope', 'apply_if_no_blockers', or 'output_path'. The schema alone 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 tool runs a built-in migration workflow and pauses for warning confirmation. It uses specific verbs ('Run', 'pause') and identifies the resource ('migration workflow'). However, it does not differentiate from siblings like 'apply_twb_migration' or 'preview_twb_migration', which may overlap.

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

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

No guidance is provided on when to use this tool versus alternatives like 'apply_twb_migration' or 'preview_twb_migration'. There is no mention of prerequisites or when not to use it. The description implies usage for guided migration, but lacks explicit context.

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

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

With no annotations provided, the description carries the full burden and does well by disclosing key behavioral traits: it describes an end-to-end pipeline, mentions external dependencies, notes that password is used only for schema inference, and specifies default values and output format. However, it lacks details on error handling or performance 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 well-structured with a clear overview followed by detailed sections for Args and Returns. It is appropriately sized for a complex tool, but the pipeline list could be more concise, and some parameter explanations are slightly verbose.

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

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

For a complex tool with 13 parameters, no annotations, and an output schema, the description is largely complete: it explains the tool's purpose, pipeline, prerequisites, parameters, and return value. The output schema handles return details, but the description could better address error cases or limitations.

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

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

Given 0% schema description coverage and 13 parameters, the description compensates by explaining most parameters in the 'Args' section, adding meaning like default behaviors and usage notes (e.g., username ignored if trusted_connection=True). It covers all required parameters and many optional ones, though some like theme and rules_yaml remain brief.

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

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

The description clearly states the tool's purpose with specific verbs ('Build a Tableau dashboard') and resources ('from a Microsoft SQL Server table'), and it distinguishes itself from siblings like csv_to_dashboard and mysql_to_dashboard by specifying the MSSQL source. The pipeline overview adds detail without redundancy.

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 this tool (for building dashboards from MSSQL tables) and mentions prerequisites (pyodbc, ODBC Driver 17), but it does not explicitly state when not to use it or name specific alternatives among siblings, such as csv_to_dashboard for non-SQL sources.

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 effectively describes the tool's behavior, including the pipeline steps (schema inference, chart suggestion, etc.), data handling (password used only for schema inference, not stored), and output (.twb file). However, it lacks details on error handling, performance, or rate limits, which are important for a complex 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 well-structured and front-loaded with the core purpose, followed by details. Most sentences earn their place, but it could be slightly more concise by integrating the pipeline list into the initial sentence. Overall, it's efficient for a complex tool with many parameters.

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

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

Given the tool's complexity, 12 parameters, no annotations, and an output schema present, the description is complete enough. It covers the purpose, pipeline, prerequisites, parameter semantics, and return summary, leveraging the output schema for return values. No critical gaps remain for effective tool 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?

Given 0% schema description coverage and 12 parameters, the description compensates fully by explaining each parameter's purpose and defaults (e.g., 'password used for schema inference only; not stored in the workbook', 'port default 3306', 'max_charts: 0 = use rules default'). This adds significant meaning beyond the bare schema, making parameter usage clear.

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

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

The description clearly states the tool's purpose with specific verbs ('Build a Tableau dashboard from a MySQL table') and resources ('MySQL', 'Tableau dashboard'), distinguishing it from sibling tools like csv_to_dashboard or hyper_to_dashboard by specifying the MySQL source. It outlines an end-to-end pipeline, making the purpose explicit and 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 provides clear context for when to use this tool (e.g., for building dashboards from MySQL tables) and mentions prerequisites ('Requires mysql-connector-python for schema inference'), but it does not explicitly state when not to use it or name alternatives like mssql_to_dashboard for other data sources, leaving some guidance 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, so the description carries the burden. It states 'in-place worksheet editing', which implies the tool modifies the workbook directly. However, it does not disclose whether it requires specific permissions, locks the file, or how it handles unsaved changes. The behavioral transparency is adequate but not thorough.

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

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

The description is a single, front-loaded sentence that clearly states the purpose. Every word is necessary, 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?

Given that there is an output schema (not shown but present) and a single parameter, the description is minimally adequate. However, it lacks context about what happens after opening (e.g., if the workbook is loaded into memory, if subsequent tools operate on it) and does not mention prerequisites like file existence or format validity.

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 there is only one parameter (file_path). The description adds no additional meaning beyond the parameter name; it does not specify path format, allowed file extensions (though implied), or whether absolute/relative paths are accepted. With low coverage, the description should compensate but does not.

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

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

The description clearly states the verb 'Open' and the resource 'existing workbook', specifying file types (.twb or .twbx) and the purpose 'for in-place worksheet editing'. It distinguishes this from sibling tools like 'create_workbook' or 'save_workbook' by focusing on opening an existing file.

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 you need to edit worksheets in an existing workbook, but it does not explicitly state when not to use it or provide alternatives. Among many sibling tools, it doesn't clarify that for creating new workbooks one should use 'create_workbook' or for saving use 'save_workbook'.

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 full burden. It does not disclose whether the tool is read-only or destructive, what side effects occur (if any), or if it modifies any state. The term 'preview' suggests no mutation, but this is not 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 a single sentence, which is concise. However, it is too terse and lacks necessary detail, making it underspecified rather than efficiently packed.

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 (4 parameters, 0% schema coverage, no annotations, but has an output schema), the description is incomplete. It does not explain what the preview returns (despite output schema existing), nor does it provide context about when to use this tool in the migration 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?

Schema description coverage is 0%, so the description must compensate, but it does not explain any parameter. The description mentions 'migration' and 'target datasource' vaguely, but does not elaborate on 'file_path', 'target_source', 'scope', or 'mapping_overrides'. The purpose of 'scope' with default 'workbook' and 'mapping_overrides' is not 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 states the tool 'Previews a workbook migration onto a target datasource.' The verb 'preview' and resource 'workbook migration' are clear, but the description is vague about what 'preview' entails (e.g., does it show potential issues, a diff, or a success/failure indicator?). It does not distinguish this from siblings like 'apply_twb_migration' or 'profile_twb_for_migration'.

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 vs. alternatives like 'apply_twb_migration' or 'migrate_twb_guided'. There is no mention of prerequisites (e.g., need to profile first) or conditions under which preview is useful.

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

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

No annotations are provided, so the description carries full burden. It describes the tool's purpose and basic operation but lacks details about permissions needed, file size limitations, performance characteristics, or error conditions. The description doesn't contradict any annotations (none exist), but could provide more behavioral context.

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

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

The description is perfectly structured: purpose statement first, sibling differentiation second, parameter explanations third, return value fourth. Every sentence earns its place with zero wasted words, and information is appropriately front-loaded.

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

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

Given the tool has an output schema (returns 'Human-readable DataProfile'), the description doesn't need to explain return values. It covers purpose, differentiation, parameters, and output type adequately. For a 2-parameter tool with output schema, this is quite complete, though could mention any prerequisites or limitations.

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

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

Schema description coverage is 0%, so the description must compensate. It provides clear semantic meaning for both parameters: 'csv_path: Path to the CSV file' and 'sample_rows: Number of rows to sample for type inference.' This adds significant value beyond the bare schema, though it doesn't specify format requirements or constraints.

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

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

The description clearly states the specific action ('Profile a CSV file') and resource ('CSV file'), distinguishing it from sibling tool 'profile_data_source' by explaining it works on raw CSV files without needing an active workbook. This provides excellent differentiation from alternatives.

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

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

The description explicitly states when to use this tool ('profile a CSV file before connecting it') and provides a direct comparison to 'profile_data_source' with clear guidance on when to choose this alternative ('Unlike profile_data_source (which needs an active workbook), this tool profiles a raw CSV file directly').

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 describes what the profile includes (dimension/measure classification, semantic types, etc.) and that it returns a 'Human-readable DataProfile with signals for template/chart decisions', which adds useful context. However, it lacks details on permissions, rate limits, or potential side effects, leaving some behavioral aspects unclear.

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 appropriately sized and front-loaded, starting with the core purpose, followed by scope details, profile contents, and parameter/return explanations. Every sentence adds value without redundancy, making it efficient 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 moderate complexity (1 parameter, no annotations, but with an output schema), the description is complete enough. It explains the purpose, usage context, parameter semantics, and return value, and since an output schema exists, it doesn't need to detail return values further. This covers all necessary aspects for effective use.

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

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

The description adds meaningful semantics for the single parameter 'source_type', explaining it's an override for source detection, with 'auto' as the default and other options like 'csv' or 'hyper' requiring separate tools. Since schema description coverage is 0% (the schema only provides a title and type), the description compensates well, though it could elaborate more on the implications of each option for a perfect score.

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

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

The description clearly states the tool's purpose with specific verbs ('profile') and resources ('currently connected data source'), and distinguishes it from siblings by specifying it works for 'ANY connection type' and includes dimension/measure classification, semantic types, etc. This is distinct from tools like 'profile_csv' or 'profile_twb_for_migration' which are more 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 provides clear context on when to use this tool: 'Profile the currently connected data source' and 'Works for ANY connection type', implying it's a general profiling tool. However, it does not explicitly state when not to use it or name alternatives (e.g., 'profile_csv' for CSV-specific profiling), which prevents a score of 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?

No annotations are provided, so the description carries the full burden. It states the tool profiles datasources and worksheet scope, implying it is a read-only analysis tool. However, it does not disclose side effects, authentication needs, or whether it modifies the workbook. The term 'profile' suggests no destructive action, but this is implicit.

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 (one sentence) and front-loaded with the verb and resource. It is appropriately sized, but could benefit from a brief mention of parameters or output without becoming verbose.

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

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

Given the tool's complexity (3 parameters, output schema exists, and multiple sibling tools), the description is minimally adequate. It covers the core purpose but lacks detail on parameters and usage context. The presence of an output schema somewhat mitigates the need to describe return values.

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

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

Schema description coverage is 0%, meaning no parameter descriptions exist in the schema. The description does not explain what 'file_path', 'scope', or 'target_source' mean or how they affect behavior. The parameter names are self-explanatory to some extent, but the description fails to add semantic value beyond their 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 'Profile workbook datasources and worksheet scope before migration' clearly identifies the tool's purpose with a specific verb ('profile') and resource ('workbook datasources and worksheet scope'). It distinguishes from sibling tools like 'analyze_twb' and 'migrate_twb_guided' by focusing on pre-migration profiling.

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 like 'analyze_twb' or 'preview_twb_migration'. It does not mention prerequisites or conditions that would trigger its use, leaving the agent to infer from the tool name alone.

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

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

With no annotations, the description carries full burden but only says 'Scan source and target schema.' It does not disclose if this is a read-only operation, whether it modifies state, what permissions are needed, or how long it might take. The output schema exists but the description doesn't hint at what it returns.

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 8 words, which is very concise. However, it is too minimal; it sacrifices clarity and completeness for brevity. Still, it avoids unnecessary words.

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

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

Given that there is an output schema, the description does not need to explain return values, but it still lacks context on tool behavior, prerequisites, and how to use parameters. The tool has 4 parameters with 0% schema description coverage, so more detail in the description is warranted.

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%, meaning the description adds no parameter details. The description does not explain the meaning of 'file_path,' 'target_source,' 'scope,' or 'mapping_overrides.' The schema provides some hints (e.g., 'scope' defaults to 'workbook'), but the description fails to clarify how these parameters affect the mapping proposal.

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 'Scan' and the resource 'source and target schema' to 'propose a field mapping.' It distinguishes itself from siblings like 'inspect_target_schema' and 'migrate_twb_guided' by focusing on proposing a mapping rather than just inspecting or executing migration.

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 like 'inspect_target_schema' or 'migrate_twb_guided.' There is no mention of prerequisites (e.g., schema must be available), nor any exclusion criteria (e.g., when not to use).

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 key behavioral traits: the tool evaluates templates against data profile and chart mix, returns a ranked list with reasoning, and uses a decider. However, it doesn't mention performance aspects (e.g., rate limits), error handling, or authentication needs, leaving some gaps.

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 and front-loaded with the core purpose, followed by usage guidelines and parameter details. It's appropriately sized, but the 'Args' and 'Returns' sections could be integrated more smoothly into the narrative flow, slightly affecting readability.

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

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

Given the complexity (evaluation and ranking tool), no annotations, and an output schema present, the description is complete enough. It covers purpose, usage timing, parameters, and return format, providing sufficient context for an agent to invoke it correctly without needing to explain return values redundantly.

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 beyond the input schema, which has 0% description coverage. It explains both parameters: 'chart_types' as a comma-separated list with an example, and 'kpi_count' as an override derived from chart_types. This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states the tool's purpose: 'Score all gallery templates and recommend the best fit.' It specifies the verb ('Score... and recommend'), resource ('gallery templates'), and outcome ('best fit'), distinguishing it from siblings like 'list_gallery_templates' (which just lists) or 'diff_template_gap' (which compares).

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

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

The description provides explicit guidance on when to use this tool: 'Call this AFTER profiling the data source and deciding on chart types, but BEFORE creating the dashboard layout.' It also distinguishes it from alternatives by specifying the decider's role, though it doesn't name specific sibling tools as alternatives.

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

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

No annotations are provided, so the description carries full burden. It mentions that the tool 'recommends templates' and returns 'ranked template recommendations', which gives basic behavioral insight. However, it lacks details on what 'templates' entail (e.g., visualization templates, dashboard layouts), how recommendations are generated, performance characteristics, or any limitations. For a tool with no annotations, this leaves significant gaps in understanding its 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 appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by structured sections for Args and Returns. There's no wasted text, and each section serves a purpose. However, the formatting with separate sections could be slightly more integrated, but it remains 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?

Given 3 parameters with 0% schema coverage and no annotations, but with an output schema present, the description is moderately complete. It covers the basic purpose, parameters, and return value, but lacks depth in behavioral context and parameter details. The output schema likely documents the return structure, so the description doesn't need to explain return values further. However, for a tool with no annotations and poor schema coverage, more elaboration on usage and parameters would improve completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It lists parameters with brief explanations: 'csv_path: Path to the CSV file', 'chart_types: Comma-separated chart types (optional)', and 'sample_rows: Rows to sample for inference'. This adds meaning beyond the schema's titles, but it's minimal—lacking details on format constraints, valid chart types, or sampling implications. With 3 parameters and no schema descriptions, this partial compensation is insufficient for full clarity.

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: 'Recommend templates for a CSV file' with the specific verb 'recommend' and resource 'templates for a CSV file'. It distinguishes from siblings by specifying 'no active workbook needed', which differentiates it from workbook-related tools like 'create_workbook' or 'open_workbook'. However, it doesn't explicitly differentiate from the sibling tool 'recommend_template' (without '_for_csv'), which might handle different input types.

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

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

The description implies usage context with 'no active workbook needed', suggesting this tool is for standalone CSV analysis rather than workbook operations. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'suggest_charts_for_csv' or 'recommend_template', nor does it mention prerequisites or exclusions. The guidance is present but limited to a single contextual note.

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 the removal action, which implies a destructive operation (deletion). However, it does not clarify whether the field is permanently deleted or can be recovered, nor does it mention any prerequisites (e.g., field must exist). The description is adequate but minimal.

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