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 reveals that the tool generates a dynamic measure and a calculated class table, but it does not mention whether this modifies the model, overwrites existing objects, requires specific permissions, or has any side effects. For a mutation-type tool without an output schema, this is a significant gap.

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

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

The description is two sentences, front-loaded with the purpose, and every clause earns its place. It concisely explains the output and threshold semantics without any filler or repetition of schema details.

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

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

For a tool with 7 parameters, no annotations, and no output schema, the description is incomplete. It mentions the generated artifacts but does not describe return behavior, default naming, prerequisites (e.g., numeric value measure, existing entity table), or potential conflicts. This leaves substantial ambiguity for an agent deciding how to call it.

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

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

Schema description coverage is 86%, which sets a baseline of 3. The description adds meaningful semantics for aThreshold/bThreshold by explaining they are cumulative-share cut-offs and that the rest fall into C, which is not fully explicit in the schema. This helps the agent understand the classification logic beyond mere parameter 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 leads with a specific verb 'Generate' and identifies the resource 'ABC (Pareto) classification'. It further specifies the tangible outputs (a dynamic class measure plus a calculated class table), which clearly distinguishes it from generic add_* tools like add_measure or add_calculated_table. This is not a tautology and provides concrete purpose.

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

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

The description implies usage for ABC/Pareto analysis by explaining the threshold cut-offs, but it does not explicitly state when to prefer this tool over alternatives such as add_dynamic_segmentation or add_measure. No when-not scenarios or alternative tool references are provided, so the guidance is only implied.

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

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

With no annotations, the description carries the transparency burden. It discloses the written payload (exact visualLink shape), the button label, and the return value, and notes the prerequisite that bookmarkName must come from list_bookmarks/add_bookmark. It doesn't discuss error handling or permissions, but for a non-destructive add operation this is reasonably transparent.

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

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

The description is compact and information-dense: every clause adds value—behavior, payload construction, parameter source, and return type. No filler or repetition of schema details.

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

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

Given the tool's moderate complexity (8 params, no output schema), the description covers the essential non-obvious details: how the button links to a bookmark, the exact visualLink shape, and the returned id. It doesn't explain the session/positioning params, but those have defaults or are conventional, so the overall tool is usable.

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 low (38%), mostly for page/text/bookmarkName. The description compensates for the key parameter by explaining bookmarkName's origin and purpose, and for text by referencing the label. However, the positioning and sizing parameters (x, y, width, height) and reportSessionId receive no description-level semantics beyond the schema defaults.

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

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

The description opens with a specific verb and resource ('Add a button bound to a BOOKMARK') and immediately distinguishes itself from generic button tools like add_button/add_nav_button by specifying the bookmark-triggered view-switch pattern. It also clarifies the behavioral effect (clicking applies the bookmark) and the return value.

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

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

It clearly states the intended use case (view-switch pattern via a bookmark) and points to list_bookmarks/add_bookmark as the source for bookmarkName, implying a prerequisite. However, it doesn't explicitly state when not to use it (e.g., for page navigation use add_nav_button), leaving a small gap in exclusionary guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the structure of conditions, combine operator, fieldKind, and valueType, which adds useful context beyond the schema. However, it does not disclose side effects (e.g., whether existing filters are replaced, whether the filter is immediately applied, or any validation behavior for invalid inputs). This is typical for a mutation tool but could be more transparent.

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

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

The description is a single, dense sentence that front-loads the core purpose and then efficiently lists the key parameter semantics. Every clause adds value, with no redundant or filler content. It avoids repeating schema information and focuses on the most actionable guidance.

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

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

For a tool with 10 parameters and a nested JSON structure, the description covers the essential usage: the condition format, allowed operators, combine logic, fieldKind, valueType, and scope-specific parameter requirements. It leaves a couple of minor gaps (e.g., what to pass for report scope, behavior when more than two conditions are provided) but is largely complete given the schema's rich parameter descriptions. The lack of an output schema means return behavior is not addressed, but the core usage is well documented.

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 high (90%), but the description adds significant meaning beyond the schema: it enumerates the allowed operators (gt|gte|lt|lte|eq|ne|isblank|isnotblank|contains|startswith), clarifies the combine option (and|or), and explains the scope-to-parameter mapping (visual requires page+visual, page requires page). This helps the agent construct valid JSON conditions and correctly choose parameters, exceeding what the schema alone provides.

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

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

The description clearly states the tool's function: adding an ADVANCED multi-condition filter with And/Or logic at visual, page, or report scope. It specifies the key differentiator (up to two conditions on the same field joined by And or Or) and explicitly distinguishes it from basic filters, making it easy to differentiate from sibling filter tools like add_visual_filter.

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

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

The description provides concrete usage context, including the scope options and the requirement to pass page+visual for visual scope and page for page scope. It does not explicitly name alternative tools or exclusions, but the 'ADVANCED' label and condition details imply when this tool is appropriate compared to simpler filter tools. Minor gap: no explicit 'use this instead of X' guidance.

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

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

With no annotations provided, the description carries the responsibility for disclosing behavior. It adds a useful caveat: 'Structure matched to the legacy analytics shape - verify the render in Desktop,' which warns about potential rendering issues and legacy compatibility. It also clarifies the meaning of 'label' as 'data-label text,' going beyond the schema. It doesn't discuss other side effects, but for a simple add-line operation this is adequate.

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

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

The description is three sentences with no wasted words. It's front-loaded with the purpose, then provides parameter rules, then adds a legacy caveat. Every sentence conveys unique, useful information.

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

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

For a tool with 9 parameters and no output schema, the description covers the purpose, parameter selection logic, and a key behavior caveat. It doesn't explain reportSessionId/page/visual, but those are standard and documented in the schema. The legacy note adds important context that a user might otherwise miss. It's complete enough for most use cases.

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

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

The input schema already covers 89% of parameters with descriptions, but the description adds essential cross-parameter semantics by explaining how 'kind' determines which other parameters are needed (constant → value; min/max/average/median → measureTable+measure; trend/forecast → none). This grouping goes beyond individual parameter descriptions and is critical for correct invocation.

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

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

The description opens with a specific verb and resource: 'Add an ANALYTICS reference line to a chart.' This clearly states the tool's function and distinguishes it from sibling tools like add_chart or add_visual since it focuses on analytics reference lines specifically.

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

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

The description provides clear context on how to use the tool by explaining which parameters are needed for each 'kind' (constant uses value; min/max/average/median use measureTable+measure; trend/forecast need no value). However, it does not explicitly name alternative tools or state when NOT to use this tool, so it stops short of full 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 burden. It adds the note 'Verify the render in Desktop' which hints at a Desktop-only verification workflow, and explains parameter effects. However, it doesn't disclose whether existing anomalyDetection settings are overwritten, nor any prerequisites or error behaviors.

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

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

The description is four short sentences, front-loaded with the main purpose, and every sentence adds useful information without fluff.

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

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

For a 5-param tool with no output schema, the description covers the purpose, key parameters, and a verification step. It lacks details on return values or edge cases, but is adequate for an add operation.

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

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

The description adds semantics for sensitivity ('higher = more anomalies') and explainBy ('the explanation groups by'), which go beyond the schema's short descriptions. It doesn't cover reportSessionId, but that's a session identifier.

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 ANOMALY DETECTION to a line chart' and identifies the object ('the anomalyDetection object'). This distinguishes it from other add-* tools like add_analytics_line or add_moving_average, and conveys the exact resource affected.

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

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

It provides context that this tool is for line charts and covers the optional sensitivity and explainBy parameters. It doesn't explicitly mention alternatives or when not to use, but the purpose is clear enough to select for anomaly detection use cases.

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 transparency burden; it discloses that it creates hidden objects, rewrites base measures, and only routes 'when possible.' The explicit FLAG warning that the IF-routing is a 'best-known scaffold' and needs review before production is valuable beyond the schema. It stops short of detailing side effects on existing aggregation tables or reversibility, but the core mutating behavior is clear.

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

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

The description is concise and content-dense: two sentences plus a needed flag. It front-loads the core purpose and provides necessary parameter formats, but the first sentence is long and packs many clauses; still, no words are wasted.

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

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

For a complex mutation tool with no annotations and no output schema, this description gives a strong overview of what will be built, the parameter syntax, and a production risk note. It leaves minor gaps (prerequisites, reversibility, return value), but the core context is present.

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

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

The description reaffirms and clarifies the comma-separated formats for groupByColumns and measureMappings, matching and slightly expanding the schema. It provides context on how the parameters map to the scaffold (hidden measures per mapping), though it does not elaborate beyond the schema for detailTable or sessionId.

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

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

The description opens with a specific verb ('Build') and resource ('auto-aggregation scaffold'), then enumerates the exact deliverables: hidden agg table, hidden measures, and IF-routing rewrites. It explicitly distinguishes itself from the sibling 'set_aggregation' by stating it extends that tool, clarifying its niche.

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

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

The phrase 'Extends set_aggregation' signals a relationship to an alternative, but the description never explicitly states when to choose this tool over set_aggregation or when not to use it. It implies usage for auto-aggregation but lacks clear exclusions or prerequisites (e.g., whether set_aggregation must be run first).

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

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

With no annotations provided, the description carries full burden for safety and behavior. It explains the internal structure (GTE + LTE joined by And) and scope handling, but it does not disclose whether the filter is additive or replaces existing filters, nor does it mention any side effects, permissions, or limitations. This leaves notable behavioral gaps for a mutation operation.

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

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

The description is three concise, information-dense sentences with no filler. Each sentence earns its place: the first defines the operation and scope, the second covers valueType and fieldKind, and the third details scope-specific parameter requirements. It is front-loaded and efficiently structured.

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

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

For a tool with 10 parameters and no output schema or annotations, the description covers the essential semantic details: scope handling, value encoding, field kind, and the inclusive bounds meaning. It does not address whether the filter is appended or replaces existing filters, and reportSessionId is left unexplained, but the core usage is clear and well-rounded.

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

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

The schema already covers 90% of parameters with descriptions, giving a baseline of 3. The description adds meaningful semantics beyond the schema: lo/hi are inclusive bounds, the operation composes two comparisons, valueType controls literal encoding, and fieldKind distinguishes column vs measure. It also clarifies the conditional requirement for page/visual based on scope, which adds practical usage value.

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 ('Add') combined with a precise resource ('BETWEEN filter') and immediately clarifies the semantic (lo <= field <= hi). It clearly distinguishes this from sibling filter tools by specifying the two-value comparison and the scope options, so an agent can easily see what unique operation it performs.

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

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

It provides clear context on when to pass page+visual versus page based on scope, which is helpful for correct invocation. However, it does not explicitly mention alternatives or when not to use this tool (e.g., versus add_advanced_filter or add_does_not_contain_filter), so it stops short of full exclusionary guidance.

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

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

With no annotations, the description carries the full burden and discloses the auto-generated name format 'Bookmark'+16 hex, the hidden/rest-shown behavior, the return of the new bookmark name, and a follow-up wiring suggestion. It doesn't cover permissions or explain the relationship between generated name and displayName, but covers most key behavioral traits.

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

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

Three dense, front-loaded sentences convey the core action, naming scheme, parameter format, return value, and usage tip without any fluff. Every sentence adds value.

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

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

For a tool with no output schema, the description covers purpose, behavior, parameters, return value, and integration. Minor gaps remain around reportSessionId context and error handling, but the essential operational flow is well-covered.

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 covers 80% of parameters. The description adds meaningful semantics by specifying hiddenVisuals as comma-separated IDs from list_visuals, clarifying the 'rest shown' default, and revealing the naming mechanism not present in the schema. However, reportSessionId remains undocumented and displayName interplay is ambiguous.

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

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

The description clearly states the tool adds a report-level bookmark with a specific view-state pattern, hiding listed visuals and showing the rest. The verb 'add', resource 'bookmark', and detailed behavior distinguish it from siblings like update_bookmark, delete_bookmark, and add_bookmark_navigator.

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 'view-state pattern' phrase and 'Wire it to a button with add_action_button' provide contextual usage guidance. It implies using list_visuals for IDs and contrasts view-state with captureData for data state, but does not explicitly name alternatives or state when not to use this tool.

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

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

The description discloses that the visual auto-lists bookmarks and can be positioned with x/y/width/height, adding behavioral context beyond the schema. However, it does not mention prerequisites (e.g., existing bookmarks), potential side effects, or whether it modifies existing visuals. Since no annotations are provided, the description carries the burden, and this disclosure is partial.

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

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

The description is two sentences, front-loaded with the core purpose, and includes positioning details without any fluff. Every word contributes meaning, making it appropriately concise and well-structured.

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

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

Given the tool's complexity (adding a visual with 6 parameters) and lack of annotations, the description is incomplete. It does not mention required parameters, specify which page the visual is added to, or describe behavior when bookmarks are absent. The no-code view-switcher context is helpful, but the description leaves significant gaps in setup and side effects.

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

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

The description explicitly states that x/y/width/height are for positioning, adding meaning to those parameters beyond their names and defaults. With schema coverage at only 17%, the description partially compensates but does not explain reportSessionId or page (though page has a schema description). Thus, it adds some value but does not fully cover the parameter semantics.

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

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

The description clearly states the tool's function: adding a built-in BOOKMARK NAVIGATOR visual that auto-lists bookmarks as buttons. It uses a specific verb ('Add') and resource ('BOOKMARK NAVIGATOR visual'), and differentiates itself as 'the no-code way to wire a view-switcher,' distinguishing it from sibling tools like add_view_switcher or add_page_navigator.

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

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

The description implicitly indicates when to use this tool by calling it 'the no-code way to wire a view-switcher,' suggesting it is an alternative to coding a view-switcher or using other navigator tools. However, it does not explicitly name alternatives or provide exclusion criteria, so it falls slightly short of full guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool writes the actionButton visualLink and returns the new visual id, and it explains the behavior of clearAllSlicers/applyAllSlicers acting on the page's slicers. It does not cover permissions or error conditions, but for a button-creation tool, the disclosed behavior is sufficient.

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: three sentences pack the actionType list, per-type parameter requirements, a note about slicer behavior, and the side effect/return value. Every sentence adds value, and the most important information is front-loaded.

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

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

Given there is no output schema and no annotations, the description covers the essential context: purpose, action-specific configuration, side effect, and return value. It omits nothing critical for adding a correctly configured button. The positional and session parameters are left to the schema, but their function is inferable.

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

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

The description adds meaning beyond the schema for the conditional parameters (bookmarkName, destinationOrUrl) and explains the actionType enumeration values. However, schema description coverage is only 50%, and the description does not explain the semantics of x, y, width, height, or reportSessionId, which remain reliant on their default values and names.

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

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

The description clearly states it 'Add[s] a BUTTON with any action' and enumerates the supported actionType values, which immediately distinguishes this from generic add_visual and sibling tools like add_action_button. It also specifies the output ('Returns the new visual id') and the side effect ('Writes the actionButton visualLink'), making the function's purpose unambiguous.

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

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

The description provides explicit guidance on which parameters are required for each actionType (bookmark needs bookmarkName, pageNavigation/drillthrough and webUrl use destinationOrUrl, others need neither), giving the agent clear instructions on configuration. However, it does not explicitly compare this tool to sibling tools like add_action_button or add_nav_button, so guidance on when to use this tool versus alternatives is only implied via the actionType distinction.

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

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

With no annotations, the description carries the full burden. It discloses key behaviors: use of SELECTEDMEASURE(), per-item format strings, and creation of the calc group if absent. But it omits what happens if the group already exists, any permissions required, or potential side effects.

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

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

The description is three focused sentences, front-loaded with the essential concept, and free of unnecessary details. Every sentence contributes to understanding the tool's purpose and behavior.

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

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

For a tool with no annotations and no output schema, the description covers core functionality, item structure, and table creation behavior. It lacks details on precedence semantics and behavior when the group already exists, making it good but not complete.

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

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

Schema covers 75% of parameters with detailed descriptions (including an example for items). The description adds semantic context about items preserving value and using format strings, but this is largely redundant with the schema's 'items' description. No significant new parameter guidance is 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 tool builds a calc group that overrides displayed format as a currency/%/scale switcher. It distinguishes itself from generic calc group tools by specifying the exact mechanism (items keep value but reformat) and provides a concrete example via the schema.

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

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

It identifies the use case ('currency / % / scale switcher') and explains that items preserve the value while reformatting, which implies when this tool is appropriate. However, it does not explicitly name alternatives or state when not to use it.

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

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

With no annotations provided, the description must disclose behavioral details. It only states the action ('Add a DAX calculated column') but does not mention that this is a mutating operation, whether it requires an existing table, how it affects the model, or potential side effects.

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

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

The description is a single, front-loaded sentence with no filler words. It is maximally concise and easy to parse.

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

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

The tool has 4 required parameters and no output schema or annotations, yet the description provides minimal operational context. It does not explain how the parameters relate, expected behavior, or any return values, leaving the agent without sufficient guidance for correct invocation.

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

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

Schema description coverage is only 25% (only 'dax' has a description). The tool description adds no parameter-level meaning beyond what the schema already implies, failing to explain the 'table', 'name', or 'sessionId' parameters. It does not compensate for the low coverage.

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

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

The description uses a specific verb ('Add') and resource ('DAX calculated column') with a target ('table'), which clearly states what the tool does. It distinguishes from siblings like add_measure and add_calculated_table by the explicit 'column' and 'DAX' terms, though it does not elaborate on 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?

No guidance is provided on when to use this tool versus alternatives such as add_measure or add_custom_column. The description simply states the action without any contextual hints, 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 full burden for behavioral disclosure. It only states the action (create) without mentioning side effects, prerequisites (e.g., open session), existence checks, or what happens to the model. For a mutation tool, this is insufficient context.

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

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

The description is a single, front-loaded sentence with a concrete example. Every word contributes, and there is no redundancy or unnecessary information.

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

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

The description conveys the core purpose but leaves gaps around required session context, parameter semantics for name/sessionId, and potential errors. Without an output schema, a bit more detail could improve completeness, but for a relatively simple create operation it is minimally adequate.

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 low (33%), with only 'dax' described. The description clarifies 'dax' as a DAX table expression, but provides no meaning for 'name' or 'sessionId'. It does not compensate for the missing parameter documentation.

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

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

The description clearly states the tool creates a new calculated table from a DAX table expression, with a concrete example (Calendar via CALENDAR()) that illustrates the intended use. It distinguishes from sibling tools like add_calculated_column or add_measure by specifying 'table' as the resource and 'DAX table expression' as the 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 example implies usage for calendar-like tables, but it does not explicitly state when to use this tool versus alternatives such as create_date_table or add_table_from_m. It lacks explicit when-to-use or when-not-to-use guidance.

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

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

With no annotations, the description carries the transparency burden. It discloses important behaviors: precedence ordering, offline mode behavior for pbip (missing table created whole, DiscourageImplicitMeasures switched on), and the engine-for-selectors concept. It could be more explicit about side effects like modifying existing tables, but the information provided goes well beyond the schema.

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

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

The description is compact and front-loaded, with three sentences each providing essential information: purpose, next step, precedence, and offline mode. No wasted words; every clause earns its place.

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

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

For a tool with 4 parameters, no output schema, and no annotations, the description covers the core functionality, sequencing, precedence, offline mode, and key behaviors. Missing details like return values are not critical given the lack of an output schema, but some side-effect information could be added. Overall, it is reasonably complete for a moderate-complexity tool.

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

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

Schema coverage is 100%, and the description still adds value by clarifying that the table must be single-column, explaining the precedence parameter ('Lower precedence is applied first when groups are nested'), and distinguishing sessionId vs pbipFolder for offline edits. This supplements the schema's field descriptions meaningfully.

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: 'Turn a (single-column) table into a calculation group' and explains its role as 'the engine for reusable selectors like Time Intelligence (Current/YTD/PY/YoY) applied to ANY measure.' This verb+resource+concept is specific and distinguishes it from sibling tools like add_calculation_item by noting the sequencing ('After this, add items...').

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

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

Provides clear context: it shows the workflow ('After this, add items with add_calculation_item'), explains precedence behavior ('Lower precedence is applied first when groups are nested'), and details the pbip offline alternative. However, it does not explicitly exclude alternatives such as add_time_intelligence_calc_group, so it lacks full when-not-to-use guidance.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states 'Add' (mutation) and describes parameters, but does not mention side effects, reversibility, permissions, errors, or return behavior, leaving significant gaps for a state-changing 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 two sentences, front-loaded with the primary purpose, and every phrase adds value. 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?

The tool has no output schema and no annotations, and while the description covers the core purpose and optional parameters, it omits behavioral context (e.g., what happens if the calculation group doesn't exist, whether changes are reversible). It is adequate but not thorough for a mutating tool.

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

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

Schema coverage is high (83%), so the schema already describes most parameters. The description adds a helpful DAX example and clarifies the purpose of ordinal and formatStringExpression, but these largely mirror the schema descriptions.

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

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

The description clearly states the tool's action ('Add a calculation item') and the target resource ('to a calculation group'), with a concrete DAX example that distinguishes it from siblings like add_calculation_group or update_calculation_item.

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

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

The description implies the tool is for creating new calculation items and provides a DAX example, but it does not explicitly contrast with alternatives like set_calc_item_ordinal or update_calculation_item, nor does it mention prerequisites (e.g., an existing calculation group).

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 significant caveat: the calendar/calendarColumnGroup objects are 'very new and absent from this build', leading to a stamped annotation workaround and instruction to confirm in Desktop. This is valuable behavioral information beyond a simple 'add' operation, though it does not discuss side effects or reversibility.

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

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

The description is compact and front-loaded with the main action and mechanics in the first sentence, followed by a brief parameter note and a crucial flag. No filler words, though the first sentence is dense.

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 no annotations or output schema, the description covers the core mechanics and a critical implementation caveat. It lacks guidance on alternatives and explicit behavioral consequences, but the essential information for invoking the tool is present.

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

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

The description adds context to the schema parameters by explaining the relationship: a calendar object on the primary date column and a calendarColumnGroup over associated period columns. It also reinforces that associatedColumns is comma-separated. With 75% schema coverage, this adds meaning beyond the bare field names.

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

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

Description clearly states the action ('Add') and the resource ('native (non-Gregorian) calendar-based time intelligence'), with specific details about creating a calendar object and calendarColumnGroup. This distinguishes it from generic time intelligence tools like add_time_intelligence or add_custom_calendar_time_intelligence.

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

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

The description implies use for native/non-Gregorian calendars but does not explicitly state when to use this versus alternatives such as add_custom_calendar_time_intelligence or add_time_intelligence. No exclusions or alternative tool references are provided.

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

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

With no annotations, the description carries the full disclosure burden. It implies creation and single-measure scope, but omits behavioral traits like whether it appends to the current page, requires a live session, or returns a visual reference. This is minimal beyond the tool name.

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

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

The description is a single, front-loaded sentence that is easy to parse. However, it is under-specified rather than appropriately concise for a 9-parameter API, so it does not achieve high marks.

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, no output schema, and nine parameters with minimal schema docs, the description is far from complete. It omits context about required session/page/table and return behavior, leaving an agent with insufficient information to invoke correctly.

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

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

Schema description coverage is only 11%, and the description only reinforces that a measure is shown; it does not explain x/y/width/height/title defaults or the role of reportSessionId/pageName/table. This does not compensate for the large undocumented parameter set.

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 adds a KPI card and constrains it to a single measure, so the purpose is specific. However, it does not differentiate from the sibling add_kpi_card, despite the near-identical name, so it falls short of full 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 usage guidance is provided: no when-to-use, prerequisites (e.g., open report session, existing page/table), or alternatives such as add_kpi_card or add_visual. The description simply states the action without context.

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

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

With no annotations, the description carries the transparency burden. It explains the semantic roles (category is the axis, value is the measure) and lists supported chart types, which is useful. However, it fails to disclose side effects, required session/page context, positioning defaults, or what the tool returns, leaving significant behavioral ambiguity 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 two sentences, front-loaded with the actual verb+object and then precise enum/domain semantics. It contains 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?

Despite having 14 parameters and no output schema, the description only addresses chartType and the category/value axis relationship. It leaves out how reportSessionId/pageName are used, the meaning of x/y/width/height, the optional series fields, and any return or result behavior, making it incomplete for safe invocation.

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

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

Schema description coverage is only 43%, so the description must compensate. It adds meaning for chartType (allowed values) and clarifies category/value table-field relationships. But it omits semantics for position/size parameters and optional series parameters, relying on parameter names and schema defaults.

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

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

The description identifies the operation ('Add a chart') and specifies chart types with a compact enum, distinguishing it from generic add_visual or table/matrix tools. It clearly defines chartType values but doesn't explicitly contrast with sibling tools like add_visual or add_matrix, so it falls just short of a top 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?

No guidance is given on when to use this tool instead of add_visual, add_matrix, or add_table_visual. It provides no prerequisites, context, or alternative references, so an agent must infer usage solely from the tool 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 carries the full burden. It transparently states that it appends Table.AddColumn to the table's M query (a mutation) and details the rule format and operators. However, it does not mention side effects like existing-column overwrites, error conditions, or prerequisites, which would have elevated it further.

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 dense but well-structured, front-loading the core purpose, then detailing syntax, operators, and types. Every sentence contributes, though the rule example and operator list make it moderately verbose. It is appropriately sized for a tool of this complexity.

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

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

Given the tool has 8 parameters, no output schema, and no annotations, the description covers the essential elements: the operation's effect, rule format, operators, and type handling. It does not explain return values or error scenarios, but the core usage is sufficiently documented for an agent to invoke it.

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

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

The schema covers 75% of parameters, but the description adds significant meaning beyond the schema by defining the exact comma-separated rule syntax (column:op:value:result), listing valid operators, and clarifying how valueType and resultType affect comparisons and outputs. This is valuable for invoking the tool correctly.

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 adds a conditional column via an ordered if/then/else rule chain, explicitly mentioning the underlying Table.AddColumn with a nested if-chain. This distinguishes it from generic add_custom_column or add_calculated_column tools by focusing on the structured Conditional Column builder pattern.

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 conveys when to use this tool: when you need an ordered conditional column based on rules. It provides examples and operator lists, but it does not explicitly name alternatives or state when not to use it, so it lacks explicit exclusions while giving clear context.

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

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

With no annotations, the description carries the full burden and discloses key behaviors: it adds a boolean column, idempotency, auto-recalculation, and return value ('Returns how many members have data vs are dead'). It stops short of mentioning prerequisites like existing relationships or permissions, but the core side effects are well described.

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

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

The description is three sentences, front-loaded with context, then action, then usage, then properties. Every sentence contributes unique value with zero redundancy.

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

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

The description explains what the tool does, how to use it, what it returns, and important properties (idempotent, auto-recalcs). It lacks explicit mention of prerequisites such as an existing relationship between the dimension and fact table, but the overall context is sufficient for an agent to invoke it correctly.

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

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

Schema coverage is 75% (3 of 4 params have descriptions). The description adds minimal parameter-level meaning beyond reinforcing the distinction between fact table and dimension. The missing sessionId description is not compensated for, but the schema itself is already descriptive, so a baseline 3 is appropriate.

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

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

The description uses a specific verb ('Adds') and resource ('boolean calculated column to a dimension'), and clearly distinguishes this tool from siblings by positioning it as 'the partner to audit_robustness' and 'Close the loop on blank-on-select'.

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

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

The description provides clear context for when to use the tool (to prevent blank-on-select by flagging dead dimension members) and references a related sibling (audit_robustness). It does not explicitly list alternatives or exclusions, but the practical usage example ('Filter slicers or add a report-level filter') makes the trigger scenario evident.

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

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

With no annotations, the description carries full burden. It discloses the purpose and outcome but does not mention side effects, error behavior, idempotency, or required permissions. No information on what happens if the culture already exists or how the addition is stored. This is a significant gap 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 two sentences, front-loaded with the action and resource, and every word contributes to understanding the tool's purpose and workflow. No redundant filler or restatement of the name.

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

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

For a simple 2-parameter tool with no output schema, the description gives a solid high-level understanding of the tool's effect and how it fits into the translation workflow. However, it lacks important operational context such as what the response/return value is, whether the operation is reversible, or what happens on duplicate cultures. The description is adequate but not complete.

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

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

Schema coverage is only 50% (locale is described, sessionId is not). The description repeats the locale examples from the schema ('fr-FR or mi-NZ') and adds 'mi-NZ' as an example, but it does not explain sessionId or any additional parameter semantics. The description adds marginal value beyond the schema and fails to compensate for the missing sessionId documentation.

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

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

The description uses a specific verb ('Add') with a clear resource ('a culture') and explains its purpose (enabling translated captions, descriptions, and display folders). It distinguishes itself from sibling tools like delete_culture and set_translation by describing its role in the localization workflow.

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

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

The description explicitly names set_translation as the tool for adding actual translations, providing clear guidance on when to use this tool versus an alternative. It implies a sequencing step ('Add a culture... Add the actual translations with set_translation'), which is actionable 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 burden of disclosing behavior. It explicitly describes that the tool creates two calculation items and the exchange-rate formula, which is meaningful behavioral context. However, it does not mention potential side effects, prerequisites, or idempotency, so it is not fully transparent.

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

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

The description is a single sentence, front-loaded with the verb 'Create', and contains no wasted words. Every element contributes to understanding the tool's function.

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

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

The tool is moderately complex with 6 parameters and no output schema. The description captures the core behavior but omits details such as how the currencyColumn is used, prerequisites (e.g., base table must be single-column, but that is in schema), and possible interactions with existing calc groups. 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?

Schema description coverage is high (83%), so the baseline is 3. The description adds some semantic context for rateTable and rateColumn by explaining the SUMX formula, but it does not elaborate on sessionId, precedence, or the currencyColumn beyond schema descriptions. It provides marginal added value.

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: creating a currency-conversion calculation group, specifying its structure (Original Value item and Converted item) and the formula (SUMX over Date * rate). This is specific and distinguishes it from generic sibling tools like add_calculation_group and add_time_intelligence_calc_group.

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

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

The description implies when to use the tool, i.e., when creating a currency-conversion calculation group. It does not explicitly mention alternatives or exclusions, but the specialized nature is evident from the name and description. A clear context is provided without explicit when-not guidance.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool builds multiple measure types (TD/PY/PYTD/prev-week/MAT) based on specific index columns (DayIndex/MonthIndex/Year/PeriodIndex) and lists the supported calendar kinds. However, it does not explicitly mention side effects like overwriting existing measures, required permissions, or whether it's a read-only or mutating operation. The generated measures are clearly stated, so it's fairly transparent.

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

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

The description is two sentences and conveys the essential purpose, supported kinds, and measure outputs without wasted words. It is dense but well-structured, leading with the main action.

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

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

The tool has no output schema and no annotations. The description comprehensively covers the tool's input requirements and output measure types. It could mention return behavior or exact naming of generated measures, but the description is sufficient for an agent to select and invoke the tool correctly. Minor gaps like prerequisites are implied by the column references.

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

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

The input schema covers 4 of 5 parameters (80%), so the baseline is 3. The description repeats the kind enum values but adds context about the required DayIndex/MonthIndex/Year/PeriodIndex columns on the calendar table, which enriches the understanding of baseMeasure and calendarTable. It doesn't add further detail for sessionId or parameter syntax.

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

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

The description clearly states the tool's function: generating integer-index time intelligence for custom calendars. It lists specific calendar types (445/454/544/weekly/13-period) and the measures built, which differentiates it from sibling tools like add_time_intelligence or add_calendar_based_time_intelligence by emphasizing the custom calendar 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 identifies the use case: custom calendars where built-in time intelligence fails. It implicitly contrasts with built-in TI but does not explicitly name alternatives or provide when-not scenarios beyond 'built-in TI breaks'. This is clear context but lacks explicit sibling tool 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?

The description discloses that it appends Table.AddColumn to the table's M query, revealing the exact transformation and that the operation modifies the query. Since no annotations are provided, this carries the transparency burden, and while it doesn't mention error handling or side effects, the explicit M code gives strong behavioral insight.

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

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

The description is three focused sentences that front-load the purpose and add essential detail without redundancy. It earns its place with a clear statement, a mechanism explanation, and a useful example—no fluff.

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

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

Given a 5-parameter tool with no output schema or annotations, the description covers the core mechanics and provides a usage example. It omits context about session/table handling and potential side effects, but the essential operation is clearly conveyed, leaving only minor gaps.

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

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

The description clarifies that mExpression references columns as [Col] and provides a concrete example, adding context beyond the schema's basic description. It also shows how name and mExpression combine in the Table.AddColumn code, giving relational meaning that the schema alone lacks, though table and sessionId remain under-specified.

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

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

The description immediately states 'add a column from an M expression,' specifying the exact action and resource. It distinguishes this from sibling tools like add_calculated_column by emphasizing M expressions and provides a concrete example, making the purpose unmistakable.

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

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

The phrase 'Power Query Add Custom Column' and the M expression syntax clearly indicate this is for Power Query transformations. It implies the right context (adding custom columns via M) but does not explicitly name alternatives or state when not to use it, landing just below the 'explicit alternatives' threshold.

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 a key behavioral trait: this adds metadata only, and a refresh is required to actually populate values. It also explains the underlying TOM limitation, adding context beyond what the schema provides.

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

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

The description is two sentences long, front-loaded with the primary purpose, and each sentence adds value. There is no filler or redundant information.

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

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

The description covers the essential context: what it does, when it's needed (after add_table_from_m), and the post-operation refresh requirement. It lacks details about error cases or return values, but given the tool's moderate complexity and no output schema, it is reasonably complete.

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

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

Schema description coverage is only 40%, covering dataType and sourceColumn. The description does not compensate by explaining required parameters like sessionId, table, or name. It mentions 'import (M) table' but does not elaborate on the parameter semantics, leaving the agent to rely on the incomplete 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: adding a data column's metadata to an import (M) table. It specifies the resource ('import table') and the action ('add metadata'), distinguishing it from other add_* tools like add_calculated_column or add_custom_column that target different column 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 provides explicit when-to-use guidance: 'Needed after add_table_from_m because TOM does not auto-infer columns.' It also instructs to refresh afterwards. However, it does not explicitly mention alternatives or when-not-to-use scenarios, so it falls slightly short of a 5.

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

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

With no annotations provided, the description carries the full burden. It discloses internal behaviors: registers guid, adds visual, binds dataRoles, and writes objects.vega[0].properties with specific formatting details. It also includes a caveat about visualGuid defaulting to the published guid, adding transparency about a potential misconfiguration. It does not cover all side effects (e.g., overwriting, errors) but is above average.

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

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

The description is a single dense sentence but efficiently packs all essential information. It is front-loaded with the main action and then details sub-operations. Slightly overlong and could benefit from bullets, but every sentence earns its place with no waste.

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

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

Given the complexity (16 params, no output schema, no annotations), the description covers the core behavior and key parameter formats but leaves gaps: it doesn't explain return values, error conditions, or prerequisites like reportSessionId. It also omits semantics for positional parameters x/y/w/h (though those have defaults). It's adequate but not complete for a tool of this complexity.

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

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

Schema coverage is 69%, so the description adds meaningful context beyond the schema. It explains that spec/config are JSON strings (schema already says), dataRoles is a JSON array of {table,field,kind}, provider/renderMode have specific enum-like values, and enable* booleans exist. It also reveals the format of jsonSpec (one-lined + single-quoted in a literal), which is not in the schema. This compensates for 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 tool's purpose: 'Add a DENEB (Vega / Vega-Lite) custom visual to a page' and enumerates specific actions (registers the Deneb guid, adds the visual, binds dataRoles, writes properties). This distinguishes it from sibling tools like add_visual or register_custom_visual by its Deneb-specific scope and detailed behavior.

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

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

The description implies when to use this tool: when adding a Deneb visual to a page, with specifics on how to structure the call (e.g., spec/config as JSON strings, dataRoles array format). It does not explicitly mention alternatives or when-not-to-use, but the context is clear enough for an agent to infer it's the correct tool for Deneb visuals.

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 behavioral transparency burden. It discloses the exact filter logic ('Not(Contains)') and scope-dependent parameter requirements, but it does not mention side effects, return values, how the filter combines with existing filters, or authorization requirements. This is adequate but has notable 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 a single, efficient sentence that front-loads the core action and includes essential conditional details. No filler or redundant repetition of schema property names.

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 7-parameter filter tool with a rich schema and no output schema, the description provides the key missing contextual information: scope handling and page/visual parameter requirements. It is sufficiently complete to guide correct invocation, though it could mention return behavior or interaction with existing filters.

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

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

The input schema already covers most parameters with descriptions (86% coverage). The description adds valuable conditional semantics by explaining which page/visual parameters are needed per scope, going beyond the schema's individual property 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 a specific action: 'Add a DOES-NOT-CONTAIN filter (Not(Contains)) on a text column.' It specifies the resource type (text column) and the filter semantics, distinguishing it from sibling filter tools like add_between_filter or add_visual_filter.

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

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

The description gives clear context by specifying valid scopes ('scope=visual|page|report') and the required parameters for visual/page scopes ('For scope=visual pass page+visual; scope=page pass page'). It does not explicitly compare to alternative tools or state when not to use, but the scope and parameter guidance is actionable.

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

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

With no annotations provided, the description bears the disclosure burden. It clearly states side effects: it adds a drill-through page filter and a Back button, and explains the user-visible right-click behavior. This is meaningful behavioral context, though it omits prerequisites, permission needs, or reversibility.

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

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

The description is compact at two sentences, with the core purpose front-loaded. The trailing 'Ground-truthed from a real report' is extraneous for an agent selecting a tool, but it does not significantly harm clarity or structure.

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 4-parameter tool with no output schema, the description conveys the primary purpose and side effects, but gaps remain: parameter meanings are incomplete, no return behavior is described, and the relation to sibling drillthrough tools is unaddressed. It is adequate but not fully self-contained.

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

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

The schema only describes drillTable and drillColumn; pageName and reportSessionId lack descriptions, yielding 50% coverage. The tool description adds conceptual context about drill-through but does not explain the role of each parameter, especially pageName and reportSessionId. With low schema coverage, the description should compensate but fails to do so.

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: making a page a drill-through target on a column, with specific behavior (right-clicking a data point on other pages offers 'Drill through'). It distinguishes from related sibling tools by focusing on the column-based, intra-report drill-through target behavior, though it does not explicitly name 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?

Usage is implied: use this when you want a page to serve as a drill-through target for a specific column. However, there is no explicit guidance on when not to use it or how it relates to sibling tools like set_drillthrough_fields or set_cross_report_drillthrough, leaving some ambiguity for tool selection.

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

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

With no annotations provided, the description covers key side effects: role creation is conditional ('if absent'), the filter is UPN-driven, and the user/mapping table is explicitly refused. It does not mention whether an existing role's filter is overwritten or what happens to permissions, but the provided behaviors are meaningful and non-obvious.

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

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

The description is two sentences, front-loaded with the primary purpose, and each sentence adds distinct value. The shape enumeration and refusal note are compact and directly relevant.

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 complex with 10 parameters and no output schema, and the description does not explain the key shape semantics (direct vs bridge vs hierarchy vs lookup), nor handling of existing roles or permission defaults. The refusal behavior and high schema coverage help, but significant behavioral gaps remain for such a configurable tool.

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

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

Schema description coverage is high at 90%, so the baseline is 3. The description adds context beyond the schema by explaining the UPN-driven filter and the refusal case, but it does not elaborate on the meaning of each shape or how parameters like pathColumn and modelPermission interact.

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 generates dynamic row-level security by creating a role and setting a USERPRINCIPALNAME()-driven filter. It specifies the resource (SECURED table) and the action (create role + set filter), and the 'dynamic' qualifier plus refusal behavior distinguishes it from static RLS or role-management siblings, though no sibling is explicitly named.

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

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

The description implies usage for dynamic RLS scenarios and lists the shape enum to guide configuration, but it does not explicitly say when to prefer this tool over alternatives like set_rls or add_role. The refusal to target the user/mapping table is a clear exclusion, but there is no direct 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It does disclose the interval semantics ('left-closed, right-open bounds') and the logical result (count of entities), but it does not clarify what the tool actually returns to the caller (e.g., a measure object or string) or whether it modifies existing measures. This ambiguity leaves room for misunderstanding the tool's direct output and side effects.

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

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

The description is two sentences, front-loaded with the main purpose, and contains no redundant words. Every clause contributes to either the action or the algorithm, making it highly efficient and easy to parse.

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

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

Given the tool's complexity and lack of annotations/output schema, the description gives a solid overview but omits practical details: what the tool directly returns, how the 'selected segment' is specified, and any limitations (e.g., handling of nulls or out-of-range values). These gaps make it harder for an agent to invoke the tool confidently without additional guesswork.

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

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

The schema already describes 7 of 8 parameters, so baseline is 3. The description adds important context by explaining the 'disconnected band table' and 'left-closed, right-open bounds,' which clarifies the roles of lowerColumn and upperColumn. It also connects measure and granularityColumn to the classification logic, enriching understanding beyond the individual schema descriptions.

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

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

The description identifies a specific action ('Generate a dynamic-segmentation measure') and explains the mechanism ('classifies an entity by a measure value against a disconnected band table') and the output ('Returns the count of entities in the selected segment'). This clearly distinguishes it from sibling tools like add_dynamic_topn or add_abc_classification by focusing on band-table-based segmentation.

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 a clear use case—dynamic segmentation using a band table—but does not explicitly state when to choose this over alternatives or what prerequisites exist (e.g., whether the band table must be sorted). While the context is useful, it lacks explicit exclusions or alternative tool references.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explains the measure's internal logic (SELECTEDVALUE with All/multiple fallback, template placeholder, optional template), which goes beyond the schema. It doesn't mention side effects or error handling, but the core behavior and the follow-up binding action are clearly communicated.

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

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

The description is two sentences and front-loads the core purpose, but the first sentence is long and packs several concepts. The example and the binding instruction are useful and earn their place. Overall it is efficient, if slightly dense.

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 measure-authoring tool with no output schema, the description provides sufficient context: the formula pattern, fallback behavior, template usage, an example, and the next step (bind_dynamic_title). It misses some details like what the tool returns (e.g., the measure name) and the sessionId context, but the core usage is complete enough for an agent to invoke it correctly.

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

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

The schema covers 83% of parameters with descriptions, so the baseline is 3. The description adds extra meaning by providing a concrete example (column Dim_Product[Category], template "Sales - {value}"), clarifying how the column and template parameters interact. It also explains the {value} placeholder, which is not in the schema, adding value beyond the structured fields.

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: authoring a DYNAMIC TITLE text measure using SELECTEDVALUE with a fallback and optional template. It specifies the verb 'author', the resource (measure), and the technical approach, and distinguishes itself from generic measure tools and from bind_dynamic_title.

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

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

The description gives clear context on when to use this tool (to create a dynamic title measure) and explicitly directs the user to bind_dynamic_title for the report-side step. It doesn't explicitly say when not to use it, but the inclusion of a concrete example and the reference to the sibling tool provides solid usage guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses the generated components and bucketing logic, but does not mention side effects on the model, reversibility, or required permissions. The description adds meaningful context but leaves some behavioral aspects 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 a single dense sentence that front-loads the tool's purpose and generated artifacts without wasted words. It is concise yet highly informative.

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 (10 parameters) and lack of output schema, the description conveys the core concept and generated artifacts well. It does not fully explain return values or side effects, but the essential purpose is clear enough for an agent to select and invoke correctly.

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

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

Schema description coverage is 90%, so the schema documents most parameters. The description does not add details about individual parameters (e.g., nMin, nMax, othersLabel) beyond what is already in the schema, making baseline 3 appropriate.

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

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

The description uses a specific verb ('Generate') and names distinct artifacts (what-if N slider, UNION+Others dimension table, rank-or-others measure), clearly differentiating it from siblings like add_topn_filter or add_visual_topn. It precisely captures the tool's unique value.

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 a clear use case (dynamic top N with an interactive slider and Others bucket) but does not explicitly mention alternatives or exclusions. It provides sufficient context for an agent to know when to use it, just lacks explicit comparison.

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 does not disclose side effects, whether it overwrites existing error bars, permissions, or potential failure modes. However, it does provide meaningful behavioral context by explaining how the kind parameter changes interpretation (byField vs byPercentage) and instructs to verify the render in Desktop, which gives some operational awareness. Since there are no annotations, more transparency would be expected.

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

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

The description is concise and front-loaded with the primary action. It efficiently packs many parameter relationships into a compact format. It loses a point for being a somewhat dense run-on structure, which could be more readable with bullet points or clearer separation of ideas.

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 (11 parameters, no annotations, no output schema), the description covers the core parameter interactions but omits practical context such as when to use the tool, prerequisites, or what happens to existing settings. The instruction to verify in Desktop hints at a render step, but not enough for a fully self-contained understanding.

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 substantial value beyond the schema by explaining the relationships between parameters: e.g., byField uses upperField/lowerField from measureTable, byPercentage uses percent, symmetrical is optional, and relation/band have specific enums. This clarifies conditional logic that the schema's per-field descriptions do not capture.

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 ERROR BARS') and the specific target ('the errorBars object' on a chart). It is distinct from sibling tools by naming the exact chart feature, so there is no ambiguity about what this tool does.

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

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

There is no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description focuses on configuration details (kind, relation, band) but does not explain the broader use case or when this tool is appropriate compared to other visual-editing tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses key mechanics: passing fields as Table[Column] references, the first generated column dropping onto a slicer, and the exact table structure built. This goes beyond a simple 'create' statement, though it doesn't mention potential side effects like overwriting existing tables.

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

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

Three sentences, highly information-dense, with the core purpose front-loaded. Every sentence earns its place, explaining the use case, input format, and output structure without waste.

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

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

Given no annotations and no output schema, the description adequately covers the tool's purpose, input requirements, and behavioral output. It is complete enough for an agent to understand how to invoke it, though additional constraints like required fields are left to the schema.

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

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

Schema coverage is 67%, and the description compensates by elaborating on the 'fields' parameter (format and usage) and the resulting table structure. It adds meaning beyond the schema for the main parameter, while sessionId remains standard with no additional need.

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 ('Create') and resource ('FIELD PARAMETER'), and explains its function as a small calculated table that lets users swap visual fields. This clearly distinguishes it from generic tools and even from related siblings like bind_field_parameter, which focuses on binding an existing parameter.

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

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

The description implies the use case (allowing a user to switch which field a visual shows) but does not explicitly state when to use this tool versus alternatives such as bind_field_parameter or add_whatif_parameter. Context is present but exclusions are missing.

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 disclosure burden. It adds useful behavioral context, such as the filter being 'Encoded as a GTE + LT pair of datetime Comparisons' and being 'UI-impossible'. However, it does not disclose potential side effects (e.g., whether existing filters are replaced, validation of inputs, or error behavior), leaving some gap 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?

Four compact sentences, tightly packed with essential information. The opening sentence states the core concept, followed by encoding details, parameter listings, and scope mapping. No redundant or filler content appears.

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 (10 parameters, no output schema, no annotations), the description covers the primary purpose, key distinguishing features, and critical parameter semantics. It does not explain every edge case (e.g., how the GTE/LT pair applies to filtering) but is sufficient for a competent agent to select and invoke the tool correctly for the main use case.

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

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

Schema description coverage is high (~90%), so the baseline is 3. The description adds value by explaining 'mode=Last|Next', 'unit=Days|Weeks|Months|Years', providing an example for anchorDate (2024-06-30), and clarifying scope-to-parameter mapping, which goes beyond the schema's terse property descriptions.

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

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

The description uses a specific verb ('Add') and clearly names the resource ('FIXED-ANCHOR relative-date window'). It distinguishes the tool from siblings by highlighting 'UI-impossible' and using 'instead of Now' to contrast with standard relative-date filters, making its unique purpose unmistakable.

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

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

Provides clear context on when to use this tool (for fixed-anchor relative-date windows) and explicit direction on parameter combinations: 'For scope=visual pass page+visual; scope=page pass page.' However, it does not explicitly name alternative tools or state when not to use it, though the 'instead of Now' contrast implies the alternative.

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

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

With no annotations, the description carries the full burden. It usefully discloses the offline PBIP TMDL behavior ('no engine') and the requirement of existing columns. However, it does not mention what happens on conflicts (e.g., if a hierarchy with the same name already exists), whether levels are validated, or any side effects beyond creation.

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

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

The description is a single, well-structured sentence that front-loads the main purpose, provides parenthetical examples, and then introduces the offline mode. Every word contributes meaning with no fluff or repetition.

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

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

For a tool with 5 parameters and no output schema, the description covers the primary usage and the offline variant. However, it does not explicitly state that exactly one of sessionId or pbipFolder must be supplied (schema shows 0 required but description implies 'instead of'), nor does it describe the expected return value or success/failure behavior. This leaves gaps for an AI agent.

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

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

Schema description coverage is 100%, providing a baseline of 3. The description adds value by clarifying the relationship between sessionId and pbipFolder ('pass pbipFolder instead of sessionId') and explicitly defining the levels format as an ordered, comma-separated list with examples. This goes beyond the schema's brief 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 function: 'Create a drill-down hierarchy on a table from an ordered, comma-separated list of existing columns.' It provides concrete examples and distinguishes this from siblings like add_hierarchy_level by specifying the creation of the entire hierarchy rather than adding a single level.

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

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

The description gives clear context for using the tool (building a hierarchy from existing columns) and explains the pbip offline mode as an alternative to using sessionId. However, it does not explicitly state when not to use this tool versus related tools like set_hierarchy_properties, leaving some room for ambiguity.

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

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

No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: how the ordinal parameter positions the level (0 = top, omitted = bottom) and that existing levels are renumbered densely. This goes beyond the schema, which only mentions the default position.

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

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

The description is a single well-structured sentence with two clauses. It front-loads the primary purpose and then specifies the crucial ordinal behavior without any wasted words.

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

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

For a tool with 6 parameters and no annotations, the description covers the main operation and the subtle ordinal behavior. It does not describe error cases or prerequisites beyond the same-table constraint, but the schema covers parameter-level details like the levelName default. It is reasonably complete for an agent to invoke correctly.

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

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

The schema covers most parameters with descriptions (column, ordinal, hierarchy, levelName), but the description adds meaning by noting the column must be on the same table (clarifying the 'table' parameter) and by explaining the renumbering side effect of the 'ordinal' parameter. This complements the 67% 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 action ('Add a level') and the target ('an existing hierarchy'), with a source constraint ('from a column on the same table'). This specific verb+resource clearly distinguishes it from sibling tools such as remove_hierarchy_level or add_hierarchy.

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

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

The description gives clear context for when to use this tool: extending an existing hierarchy by adding a level backed by a column on the same table. It does not explicitly name alternatives or exclusions, but the specificity makes the intended use obvious.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the sequence of operations (registers, adds, binds) and the prerequisite for the measure, which is useful. However, it does not disclose potential failure modes, permissions needed, or what happens if the measure does not return HTML or the guid is invalid.

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

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

The description is three concise sentences, front-loaded with the main purpose, followed by prerequisites and an optional override. No redundant information or fluff.

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

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

Given the 9 parameters, no output schema, and no annotations, the description is adequate but incomplete. It explains the core workflow and key parameters, but omits details on coordinate parameters, reportSessionId, and expected return value or errors. There are clear gaps for an agent to fully understand the tool.

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

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

Schema coverage is 44%, with descriptions for name, page, visualGuid, and daxHtmlMeasure. The description adds context for daxHtmlMeasure (must return HTML string) and visualGuid (certified guid in Desktop), but does not clarify h, w, x, y, or reportSessionId. Thus it partially compensates for the schema gaps.

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: adding an HTML Content (lite) custom visual bound to a DAX measure, including the steps of registering the visual type, adding the visual, and binding the measure to the content role. This distinguishes it from sibling tools like add_deneb_visual or add_visual.

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

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

The description provides clear usage context: use this tool when you have a DAX measure that returns HTML/CSS and need to add an HTML Content visual. It gives a prerequisite (the measure must already exist and return an HTML string) and notes the optional visualGuid override. It does not explicitly mention alternatives or exclusion cases, but the context is sufficient.

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

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

With no annotations, the description carries the transparency burden and delivers by explaining the exact formulas for abs and rel, the expected base measure naming convention, and the effect of applyIbcsFormat. It does not cover error handling, overwrite behavior, or permissions, but the core computation and key assumptions 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 exceptionally concise, with three sentences that each add essential information: purpose, formulas, and naming/format expectations. No filler or redundant content; it is well-structured and front-loaded with the primary action.

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

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

For a 7-parameter tool without an output schema, the description covers the main decision points and algorithmic behavior. It does not mention return values or edge cases (e.g., missing base measure), but given the complexity and the provided schema, the description is sufficiently complete for correct invocation in most scenarios.

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

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

The schema already describes most parameters, but the description adds meaningful semantics beyond the schema: it defines the kind formulas, explains the '<actual> <comparison>' naming convention for the base measure, and clarifies that applyIbcsFormat adds a leading sign. This goes well beyond the baseline for 86% 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 function: authoring IBCS variance measures against a comparison base (PY, PL, FC). It distinguishes itself from generic measure-creation tools by specifying the variance types (abs/rel) and the IBCS format, making it unambiguous and specific.

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

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

The description provides clear context for when to use this tool: when creating IBCS variance measures with year-over-year or plan comparisons. It does not explicitly name alternatives or state when not to use it, but the specialized purpose and formula details imply the appropriate scenario strongly enough.

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

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

With no annotations provided, the description carries full burden and does disclose key behavioral traits: it 'embeds the file into the .pbix as a resource' (a side-effect with file size implications) and 'adds an image visual'. It also enumerates the scaling options. While it doesn't cover permissions or error behavior, the embedding behavior is a significant non-obvious trait that goes beyond a generic 'add image' statement.

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

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

Two sentences front-load the core action and embed details efficiently. The brand kit phrasing adds context without redundancy, and the scaling line is a compact reference.

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

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

For a tool with 8 parameters, no output schema, and no annotations, this description leaves too many gaps: no explanation of x/y/width/height semantics, no mention of required session/page context, and no indication of return values or error conditions. The simple use case is clear, but operational completeness is lacking.

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

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

Schema description coverage is low (25%), so the description must compensate for undocumented parameters like x, y, width, height, pageName, and reportSessionId. It only re-echoes the scaling enum and gives an example ('brand LOGO') for imagePath, but does not explain coordinate units, defaults (already in schema), or how to obtain required session/page identifiers. This is insufficient for a tool with 8 parameters.

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

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

The description uses a specific verb ('Place') and resource ('an image on a page') with concrete detail about embedding the file into the .pbix and adding an image visual. It clearly distinguishes itself from generic tools like add_visual by focusing on image resources and brand logo use case.

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

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

The description provides clear context: use this for placing a brand logo in the report, explicitly noting it 'Completes the brand kit (logo IN the report, not just the palette)'. While it doesn't name alternatives or exclusions, the brand kit framing gives a specific use case that implies when to choose this tool over generic visual-adders.

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 discloses key behavioral semantics: exclude=true maps to 'Not In', false maps to 'In', and values can be comma-separated or a JSON array. It also clarifies conditional parameter requirements per scope, adding meaningful behavior beyond what the schema alone conveys.

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 tight two-sentence summary that front-loads the purpose and packs syntax details without redundancy. Every clause adds value, and the structure is logical: purpose, parameter formats, then scope-specific guidance.

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

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

The tool has 9 parameters with no output schema, and the description covers the main functional parameters (values, exclude, valueType, scope, page/visual). Slight gaps include not addressing reportSessionId explicitly or clarifying how table/field relate to schema identifiers, but overall it is sufficiently complete for a filter-add operation.

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

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

Schema coverage is high (89%), so baseline is 3, but the description adds critical meaning: values format, exclude mapping, valueType options, and scope-dependent parameter usage. This goes well beyond the schema, making parameter semantics very 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 it adds an include/exclude filter and specifies the scopes (visual, page, report). It uses a specific verb and resource, distinguishing it from generic filter tools by describing the right-click include/exclude behavior.

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

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

It explains valid scopes and how to select the target (page+visual for visual scope, page for page scope). However, it does not explicitly compare with alternative filter tools like add_visual_filter, leaving some ambiguity about when this specific include/exclude variant is preferred over other filter mechanisms.

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 for behavioral disclosure. It only states the mechanical effect (appends to the M query) but does not disclose side effects, permissions, reversibility, or behavior with existing index columns. This 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 a single, front-loaded sentence with no wasted words. It efficiently conveys the tool's purpose and implementation in two short clauses.

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

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

Despite being a relatively simple transformation tool, it has 6 parameters, no output schema, and no annotations. The description covers the core action but omits prerequisites, return values, and edge cases, making it incomplete for reliable autonomous invocation.

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

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

The schema already provides descriptions for 4 of 6 parameters, but the description adds no parameter-level meaning. It does not compensate for the undocumented table and sessionId parameters, and the moderate schema coverage (67%) is not high enough to rely on schema alone.

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

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

The description clearly states the action ('add a sequential index') and the specific resource ('Power Query Add Index Column'), and it distinguishes the tool by noting it appends Table.AddIndexColumn to the table's M query. This is a specific verb+resource combination that separates it from other add_* sibling 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 when an index column is needed, but it provides no explicit guidance on when to use this tool over alternatives, nor does it mention any exclusions. There is clear context but no direct comparison to similar add_* operations.

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

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

With no annotations, the description carries the full burden. It adds valuable behavioral context by stating the card is 'composed from proven primitives so it always renders', which is a meaningful reliability guarantee beyond the schema. It also describes the visual style, but does not disclose potential side effects (e.g., overwriting existing visuals), though the non-destructive nature seems intuitive.

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

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

The description is compact and efficient, using two sentences to convey purpose, visual details, differentiation, and parameter guidance. It is front-loaded with the main action and contains no fluff, earning a high score.

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

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

For a complex tool with 16 parameters, no annotations, and no output schema, the description covers the essentials: what it does, how to use key optional parameters, and how it differs from a sibling. It leaves color/position parameters to schema defaults, which is acceptable. Missing return-value description is mitigated by the absence of an output schema.

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

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

Schema coverage is 63%, so the baseline is 3. The description adds relational guidance for parameters: it links deltaMeasure to comparison and the trendMeasure + dateTable/dateColumn combination to sparkline. This clarifies how to configure the optional features, which is more than the schema's individual descriptions provide, elevating the 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: 'Add a PREMIUM KPI card' with a detailed visual breakdown (white rounded panel, uppercase label, big value, optional delta and sparkline). It also distinguishes from a sibling tool by saying 'Far richer than add_card', making the specific resource and value proposition clear.

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

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

The description provides explicit usage context by comparing to add_card and explaining how to enable optional features ('Pass deltaMeasure for the comparison, and trendMeasure + dateTable/dateColumn for the sparkline'). It doesn't explicitly say when not to use alternatives like add_sparkline, but the premium positioning implies a clear choice for richer KPI visuals.

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

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

With no annotations, the description carries the full burden of disclosing side effects. It only says 'Add a matrix' and describes the data structure, but does not disclose that this modifies the report, requires an open session, or any other behavioral consequences. No safety profile is provided.

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

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

The description is two sentences, front-loaded with the core action, and every word adds value. It is concise without being overly terse, though some necessary detail is missing.

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

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

For a tool with 10 parameters, no annotations, and no output schema, this description is insufficient. It explains only the data structure for rows/columns/values but omits how position, size, title, session, and page context work, leaving the agent without enough information to use 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 semantic meaning for rows, columns, and values, clarifying they are JSON arrays of {table,field,kind} and that values are measures. However, schema coverage is only 30%, and the description does not explain the other seven parameters (position, size, title, etc.), leaving most parameters under-documented.

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

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

'Add a matrix' clearly states the action and resource, and the clarification about rows/columns/values as JSON arrays of {table,field,kind} distinguishes it from generic visual-add siblings like add_table_visual or add_chart. However, it doesn't explicitly mention 'visual' or 'to the report', so it's not fully 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?

Usage is implied: you use this when you want to add a matrix with specified rows, columns, and values. But there is no explicit guidance on when to choose this over alternatives like add_table_visual or add_chart, nor any exclusions or prerequisites.

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

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

With no annotations provided, the description carries full burden and delivers rich behavioral detail: commits to the live model, requires File > Save to persist, and the PBIP mode is engine-free, collision-checked, and preserves /// doc comments. This goes well beyond the schema and gives essential safety and side-effect information.

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

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

Three sentences pack the core action, live-model commit caveat, and offline mode details with zero fluff. The structure is front-loaded with the primary purpose, making it easy to scan and digest.

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

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

The tool has 8 parameters, no annotations, and no output schema. The description covers both operational modes, the persistence caveat, and key offline behaviors. It could mention potential errors or prerequisites (e.g., needing a connected model), but given schema richness, this is fairly complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by clarifying the sessionId vs. pbipFolder exclusivity and introduces extra behavioral context for the pbipFolder parameter (collision-checked, doc comments preserved). This enhances parameter understanding beyond the schema definitions.

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

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

Description clearly states 'Add a DAX measure to a table' with a specific verb and resource, and it distinguishes the two operating modes (live vs. offline PBIP). This differentiates it from sibling tools like update_measure or delete_measure, making the purpose unmistakable.

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 each mode: live model with sessionId, or offline PBIP with pbipFolder. It states the persistence requirement for the live model ('persist with File > Save in Desktop') and the offline nature of the PBIP mode. However, it does not explicitly name alternative tools (e.g., update_measure for modifications), so it falls short of the top criterion.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the primary action (generates a measure) but does not mention side effects, whether existing measures are overwritten, or prerequisites like having a valid date table. This is minimal but not outright 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 sentence with a brief unit note. The main verb 'Generate' is front-loaded, and every word contributes. No redundant or filler content.

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

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

For a 7-parameter tool with no annotations and no output schema, a single-sentence description is insufficient. It does not explain prerequisites, behavior on missing or partial periods, where the measure is added, or the expected overall outcome. The description is adequate for purpose but lacks depth for a tool of this complexity.

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

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

Schema description coverage is 86%, so the baseline is 3. The description adds slight meaning by clarifying the window via 'last N periods' and the unit default, but it does not elaborate on parameter semantics beyond what the schema already documents.

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

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

The description clearly states 'Generate a rolling moving-average measure over the last N periods', which specifies a distinct operation (generating a specific measure type) and differentiates it from sibling time-intelligence tools like running totals or general time intelligence.

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

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

The description implies the tool is used when a rolling moving-average is needed, but it does not state explicit when-to-use conditions or mention alternatives such as add_running_total or add_time_intelligence_measures. No exclusions or comparative guidance is provided.

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

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

With no annotations provided, the description carries the full burden. It explains the create-or-update semantics, the metadata attachment, and the effect of allowedValues. However, it doesn't mention return behavior, error conditions, or side effects beyond the parameter entry itself, which is a notable gap for a mutation tool.

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

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

The description is a single, information-dense sentence that front-loads the primary action. No filler or redundant wording; every clause adds value.

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

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

For a tool with 5 parameters and no output schema, the description covers the core purpose, key behavioral aspects, and parameter constraints. It misses details like return values or prerequisites, but these are less critical given the tool's relatively low complexity and the schema's coverage.

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 high (80%), so the baseline is 3. The description adds slight meaning by explaining type options and allowedValues as a 'fixed list', but it doesn't add much beyond the schema descriptions. sessionId remains undocumented in both schema and description, though it's likely a common 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 tool's function: 'Create (or update) a Power Query parameter' with specific details about the metadata it carries (IsParameterQuery). It distinguishes itself from siblings like set_shared_expression or define_udf by referencing the 'Manage Parameters entry' and the specific metadata flag.

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

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

The description gives useful context on parameter types and the allowedValues restriction, implicitly signaling when this tool is appropriate. However, it does not explicitly name alternatives or state when NOT to use this tool, leaving some room for ambiguity among similar shared-expression 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, the description carries the burden. It explains the measure's logic and live-update behavior, but doesn't address whether it overwrites an existing measure with the same name, required permissions, or other side effects. The 'create' verb makes the mutating nature clear, but more detail would improve 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 concise and front-loaded, with the verb and resource in the first phrase. Each sentence provides distinct value: what it creates, how it works, and where to use it. No redundant filler.

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

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

Given the tool's moderate complexity with 9 parameters and no output schema, the description covers the key functional behavior and usage context. It doesn't mention return values or prerequisites like existing measures, but the schema descriptions and the examples for each measure parameter fill in much of the gap.

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

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

The schema covers 89% of parameters individually, so baseline is 3. The description adds significant context by explaining that the top-N members are based on contribution to the change (current - prior), which clarifies the roles of currentMeasure, priorMeasure, dimColumn, and topN.

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

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

The description clearly states the tool's function: 'create a dynamic DAX text measure' that names top-N contributors and states overall growth. It distinguishes this from the native smart-narrative visual and from generic add_measure by the auto-narrative behavior.

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

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

It implies when to use (for insight text in a card, as an alternative to the native visual) and mentions the live-update behavior with slicers. It doesn't explicitly list exclusions, but the context is clear enough for an agent to select it appropriately.

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

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

With no annotations, the description adds some context like 'Structure matched to Power BI ground truth' and clarifies targetPage semantics. However, it does not disclose validation behavior, side effects, or how the button is integrated into the page, leaving key behavioral aspects unexplained.

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

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

Four concise sentences with no filler; each adds value—purpose, ground truth fidelity, composition guidance, and targetPage clarification. Well front-loaded.

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

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

For a 10-parameter tool with no annotations and no output schema, this description is too thin. The crucial distinction between pageName (placement page) and targetPage (destination) is not explicitly explained, and positional/color parameters remain ambiguous, making it hard for an AI agent to invoke correctly.

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

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

Schema covers only 40% of parameters, leaving six undocumented. The description only restates targetPage's meaning already in the schema and offers no explanation for pageName, reportSessionId, x/y, width/height, or color parameters, failing to compensate for the low coverage.

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

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

Clearly states 'Add a navigation button that jumps to another page (multi-page navigation)' with a specific verb and resource. Distinguishes from siblings like add_button by emphasizing the navigation purpose and mentioning 'Compose several into a nav bar/sidebar'.

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

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

Provides clear usage context by noting 'Compose several into a nav bar/sidebar', indicating typical scenarios. However, it does not explicitly name alternatives or exclusions, so it falls short of a 5.

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