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

The description discloses default behavior (pages defaults to current, ["*"] captures all) and output location. However, it does not explain whether compare overwrites the existing baseline, what happens if the name already exists, or if the tool requires prior capture. No annotations exist to supplement this.

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

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

The description is extremely concise: three short lines covering the three actions with per-action details. It is front-loaded with the core verbs ('Capture / compare / list') and avoids any extraneous information.

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

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

Given the absence of annotations and output schema, the description provides a solid overview of the tool's purpose, actions, and key parameters. It is nearly complete but could mention whether name is required for capture/compare and potential overwrite behavior.

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

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

With 0% schema description coverage, the description adds essential meaning: it defines 'capture', 'compare', and 'list' actions; explains pages formatting (default current, ["*"] all); and indicates name is used in the output filename. However, it does not fully clarify whether name is required for capture/compare or its permissible values.

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

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

The description clearly states the tool captures, compares, or lists value baselines. It specifies exactly what is stored (cards, badges, visibleVisualCount) per page, and differentiates the three actions (capture, compare, list) with distinct behaviors.

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 its siblings (e.g., pbi_snapshot, pbi_read_cards). The context of baselines (e.g., for regression testing) is implied but not explicit, and there is no mention of prerequisites or when not to use it.

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

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

With no annotations, the description carries the full burden and exceeds basic expectations by disclosing the overlay-intercept fallback, the return format including method and candidateCount, and the ctrl modifier for action buttons. It does not address safety or side effects, but the behavioral traits are well communicated.

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

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

The description is very concise: two sentences that front-load the purpose and key details. Every word adds value, with no fluff or repetition. It is well-structured 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 moderate complexity (6 parameters, multiple identification methods, no output schema), the description covers identification, modifier, and return, but lacks explanation of 'tag-then-act', the coordinate fallback mechanism, and differentiation from other interaction tools. It is adequate but not complete for a deep 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?

Schema description coverage is 0%, so the description must compensate. It adds meaning for text, ariaLabel, selector, ctrl (action buttons), and index (disambiguation), but omits report_selection entirely. This partial coverage results in adequate but incomplete 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 states the specific action (click) and the identification methods (text, ariaLabel, selector), along with modifier (ctrl) and disambiguation (index). It clearly distinguishes from sibling tools by being the generic click operation.

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

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

The description provides no guidance on when to use this tool versus alternatives like pbi_context_menu or pbi_deselect. It does not specify contexts, prerequisites, or exclusions, leaving the agent without decision support.

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 thoroughly discloses key behaviors: right-click location (SVG on-path else bbox center), menu item matching (exact then contains), return value shapes, and Escape key to close menu when not clicking. No contradictions.

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

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

The description is concise and front-loaded with the main purpose. However, it is a single dense paragraph that could benefit from clearer structuring (e.g., separating behavior, parameters, return values).

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

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

Given 3 undocumented parameters and no output schema, the description covers return structure and core behavior well but fails to explain the selector and ariaLabel parameters, leaving the tool incomplete for an agent to use accurately.

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

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

The schema has 0% description coverage, so the description must explain all parameters. While 'click' is implied in the behavior description, 'selector' and 'ariaLabel' are not explained at all, leaving the agent uncertain about their purpose and usage.

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

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

The description clearly states the tool's purpose: to right-click a data point/visual to open a context menu, read items, and optionally click an item. It distinguishes itself from sibling tools like pbi_click by focusing specifically on context menu interactions.

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 indicates when to use the tool (for context menu interactions) but does not explicitly state when not to use it or provide alternatives. It implies differentiation from general click tools but lacks explicit guidance.

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

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

With no annotations, the description carries full burden. It discloses that it clicks, judges cross-filter firing, and optionally restores. It mentions return values including highlightsBefore/After and changedCards. However, it does not detail side effects like state changes to the visual or potential waits, and does not cover error behavior.

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

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

The description is concise, with two sentences that cover main action and return. It is front-loaded and avoids redundancy. However, it could be slightly improved by including parameter details without adding much length.

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 output schema, the description does include return format. However, it lacks prerequisites (e.g., visual must exist), error conditions, or scenarios where cross-filter may not fire. For a testing tool, this information is crucial for correct usage.

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

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

Schema description coverage is 0%, so description must compensate. Only 'restore' is explained ('Optional restore re-clicks and verifies baseline'). The 'selector' and 'ariaLabel' parameters are not described, leaving ambiguity about their purpose and usage.

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

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

The description clearly states the tool's purpose: clicking a data point and judging whether a cross-filter fired, with optional restore. It uses a specific verb ('test') and resource ('cross-filter'), and distinguishes from sibling tools like pbi_click and pbi_read_cards by combining click with verification.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., pbi_click or pbi_read_cards). It does not state prerequisites, edge cases, or when not to use it. The description only explains what it does, not the context of use.

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

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

Despite no annotations, the description thoroughly discloses behavioral traits: overwrites prior content, runs via F5 with fallback, requires view to be opened, and specifies return format (ran, columns, rows, rowCount, error?). No contradictions.

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

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

Well-structured with front-loaded purpose. However, the overwrite warning is mentioned twice, slightly reducing conciseness. Still efficient overall.

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 absence of output schema, the description covers required prerequisites, behavior, return values, caveats, and usage guidance comprehensively.

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 explaining that the 'dax' parameter 'Overwrites the editor content' and that 'timeoutMs' is polling time, providing extra context beyond the schema.

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

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

The description clearly states the action (Write DAX and run it) and the resource (DAX query view editor) with a specific verb 'Write' and 'RUN', and distinguishes from sibling tools like pbi_read_dax_editor by specifying the execution aspect.

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

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

Provides explicit context: when to use (to run DAX), prerequisites (view must have been opened in Desktop), and a clear caveat (overwrites editor content, unrecoverable) with advice to use a throwaway query view.

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

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

With no annotations, the description carries full burden. It declares the tool is 'Read-only; safe' and details the return structure for each mode (axtree cap, dom size probe, heap usage). No side effects or prerequisites are mentioned, but the read-only assurance is strong.

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

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

The description is well-structured with clear sections for each mode using colons. It is verbose but includes essential details without unnecessary fluff. Front-loaded with the core purpose.

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

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

Given no output schema, the description adequately covers return values for all three modes. Parameter descriptions are complete. Missing aspects like error handling or edge cases are minor, as the tool seems straightforward.

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 3. The description adds meaning by explaining the purpose of each mode ('compact projection', 'size probe', 'usage') and noting defaults ('default axtree', 'default 500' for maxNodes), going beyond the enum and type info.

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

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

The description clearly states the tool performs a 'Raw-CDP deep inspection of the reportView page' and lists three specific modes with their outputs. It distinguishes itself from sibling pbi_snapshot by emphasizing 'deep' inspection, but does not explicitly contrast with it.

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

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

No guidance on when to use this tool over alternatives or on choosing between the three modes. The description does not provide context for usage decisions.

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

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

With no annotations, the description must fully disclose behavior. It mentions the trick and return values but does not clarify whether the operation is destructive or reversible, what side effects occur (e.g., clearing filters), or any permissions needed. The term 'clear selection' implies mutation, but no safety information 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 very concise: one sentence and a return type line. It is front-loaded with the core action. However, the jargon 'neighbour-page-and-back trick' could be expanded slightly for clarity, but overall it is efficient with 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 the tool's simplicity (no parameters, no output schema), the description covers the basic purpose and return shape. However, it lacks explanation of the trick's implications, the exact return fields' meanings, and when this tool is appropriate compared to peers. It is minimally complete.

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

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

The input schema has no parameters (100% coverage by schema), so the baseline is 3. The description does not need to add parameter details, but it does not explain any implicit inputs or the behavior of the trick beyond the schema. It adds some context but no additional 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 clears visual/group selection and specifies the technique used ('neighbour-page-and-back trick'). It distinguishes itself from siblings like pbi_click or pbi_context_menu. However, the jargon may be slightly ambiguous for an AI agent, preventing a perfect score.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., clicking the canvas). The description only states what it does, not the context or prerequisites. An agent would have no information about ideal scenarios or when to avoid 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?

No annotations provided, so description carries full burden. Explains actions, return values, and a safety rule about 'Save' button. Transparent about click matching behavior.

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

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

Well-structured with sections for actions and safety. Slightly verbose but every sentence adds information. Front-loaded with purpose.

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

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

Covers both actions, required parameters, return values for success and failure, and safety constraints. No output schema but return values are described.

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

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

Schema coverage 50% only documents action enum and button label. Description adds matching strategy (exact then case-insensitive contains) and safety rule, providing value beyond 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?

Clearly states it automates a Desktop dialog with specific actions 'read' and 'click'. Distinguishes itself from siblings by mentioning the CDP target and dialog-only existence.

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

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

Explicitly says when to use (dialog showing) and what happens when not ('no dialog showing'). Does not mention alternatives among siblings, but no other dialog tool exists.

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

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

With no annotations, the description fully discloses behavior: it returns {emulated, scheme}, notes that it is effectively inert for PBI report canvases, and why. Also mentions the verification date and limitations.

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

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

The description is front-loaded with the action and return, then provides essential context. The middle sentence is somewhat long but packs necessary nuance. No unnecessary words.

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

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

Given no output schema, the description explains the return object. It covers behavior, limitations, and reset advice. All relevant context for an AI agent to use correctly 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 meaning beyond the schema by listing the three enum values (light, dark, no-preference) and explaining their role. Although schema coverage is 0%, the description compensates well.

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: forcing the WebView media query prefers-color-scheme to light/dark/no-preference. It distinguishes itself from siblings by being a media query emulation tool, not a UI interaction or data retrieval tool.

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

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

Provides explicit context on when to use the tool (testing prefers-color-scheme), and importantly, when not to expect visual changes in PBI report canvases. Advises resetting to 'no-preference' when done, giving clear usage boundaries.

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?

Discloses key behaviors: evaluates JS, returns JSON-serialized result, and notably the 'best-effort textual guard' for access token rejection. However, does not mention potential side effects on page state or error handling.

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

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

Two concise sentences with no redundant text. Front-loaded with 'Escape hatch' for immediate purpose recognition. Every line adds value.

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

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

Given the tool's complexity (code evaluation) and lack of output schema, the description omits crucial context: what the JSON-serialized result contains, error behavior, and security implications beyond the token guard.

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

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

With 0% schema description coverage, the description partially compensates by specifying the parameter is a 'function-body or arrow-fn string'. But lacks details on expected format, syntax rules, or limitations beyond the token guard.

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

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

Clearly states it evaluates JavaScript code in the reportView page using specific verb 'evaluate' and resource 'function-body or arrow-fn string'. The 'escape hatch' label distinguishes it from other tools by implying low-level, unrestricted execution.

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

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

Does not explicitly state when to use this tool versus siblings like pbi_run_code. Provides only a constraint (rejects powerBIAccessToken references) but no contextual guidance on preferred 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?

No annotations are provided, so the description must carry the full burden. It discloses the trusted coordinate click mechanism, auto-expansion of groups, and return format. However, it does not mention error conditions, prerequisites (bookmark must exist?), or side effects (e.g., navigation).

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: the first explains purpose and mechanism, the second lists return values. Every word contributes, and key 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?

For a tool with 3 parameters, no output schema, and 29 siblings, the description covers core action and return type but lacks parameter details (expectPage missing), prerequisites, error handling, and comparison to similar tools. The return value info partially offsets the missing 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 0% with 3 parameters. The description only explains 'name' (bookmark name) and vaguely mentions 'group' (optional group), but does not describe 'expectPage' at all. This is a significant gap given no 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 explicitly states the verb 'fire' and the resource 'bookmark', and mentions the specific UI mechanism (View > Bookmarks pane, trusted coordinate click) and scope (ANY bookmark, optional group, auto-expand). This distinguishes it from sibling tools like pbi_goto_page or pbi_click.

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 firing bookmarks by name, but provides no explicit guidance on when to use this tool versus alternatives (e.g., pbi_click, pbi_goto_page). No when-not or exclusion criteria are mentioned.

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

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

No annotations provided, so description fully bears responsibility. Details timing: returns on tab switch but canvas may still render, waitReady blocks up to 30s. Discloses error behavior: returns closest candidates on not-found. 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?

Two sentences with no waste. First sentence defines core function; second sentence packs behavioral details, blocking option, and error handling. Front-loaded and efficient.

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

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

No output schema, yet description explains return behavior (closest candidates on not-found). Covers navigation, timing, blocking, error recovery. Siblings include many tools but this one is self-contained. Complete for an action 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 100%, so baseline is 3. Description adds value by explaining the effect of waitReady (blocking vs non-blocking) and the return timing context, which goes beyond the schema's parameter descriptions.

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

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

Clearly states navigate to a page by exact name. Verb and resource are specific. Distinguishes from sibling tools like pbi_pages (listing pages) and pbi_fire_bookmark (bookmark navigation).

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 when-to-use context: navigation requiring exact name. Advises using pbi_wait_for when not blocking, and explains waitReady:true behavior for waiting on rendering. Does not explicitly contrast with alternatives but covers key scenarios.

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

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

The description indicates the tool performs a trusted mouse-move hover and returns tooltip text or null. It does not disclose behavioral traits such as potential side effects, required navigation state, or behavior if the target element is not found. With no annotations, it carries the full burden but leaves 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 two sentences: first defines action and parameters, second defines return value. Every sentence earns its place, no fluff, front-loaded with key 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?

Given the tool has 4 parameters, no output schema, and no annotations, the description is incomplete. It fails to explain selector and ariaLabel, coordinate system for offsets, whether offset values are optional, or if hover triggers tooltip display. The description does not fully compensate for the missing structured metadata.

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

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

With 0% schema coverage, the description must compensate. It explains offsetX/offsetY as off-center aim (e.g., donut ring), but does not mention selector or ariaLabel parameters. The description adds value for two parameters but leaves half undocumented, making it insufficient for agent understanding.

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 performs a trusted hover to read tooltip text, specifying offsetX/offsetY for off-center aiming (e.g., donut ring). It distinguishes from siblings like pbi_click and pbi_context_menu, which perform different actions.

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

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

The description implies usage for reading tooltips on hover, and provides practical guidance on aiming with offsets. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention when not to use it or any 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 reveals full behavioral details: launcher resolution order (PBI_DESKTOP_BRIDGE env → path → direct), injection of WebView2 remote-debugging env var, detached spawning, waiting for CDP port, reuse of existing instance if port is up, and pre-flight warning. This is highly 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, well-structured paragraph. It front-loads the primary action, then efficiently covers resolution order, spawning mechanics, port reuse, pre-flight warning, and post-launch instruction. Every sentence serves a purpose with 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 the tool's complexity (debug port launch, multiple launcher paths) and absence of output schema, the description is remarkably complete. It explains inputs, process, edge cases (port already up), and expected follow-up (pbi_wait_for). No gaps remain for an agent to use this tool correctly.

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

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

Schema description coverage is 100%, so schema already documents the three parameters. The description adds valuable context: explains default values for port (9222) and waitPortMs (240000), and provides additional meaning for pbip (absolute path). It goes beyond the schema by explaining launcher resolution and post-launch behavior.

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: 'Launch Power BI Desktop on a .pbip WITH the CDP debug port.' It specifies the exact resource (pbip file) and the key action (launch with debug port). This is specific and distinct from sibling tools like pbi_wait_for or pbi_pages.

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, including pre-flight warnings about orphaned processes, and post-launch guidance: 'After it returns cdpUp:true, call pbi_wait_for {text:"<page name>"} — the canvas is still rendering.' It also explains behavior when port is already up, avoiding redundant launches.

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

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

Without annotations, the description carries full burden. It discloses the re-render side effect and return structure, but does not mention destructiveness, required state, or failure conditions. The behavioral 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 very concise with a single sentence plus a return note. It is front-loaded and contains no superfluous words.

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

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

The description lacks explanation of the return values (rowsBefore, rowsAfter) and the effect of the 'collapse' parameter. Given no output schema and 0% schema coverage, the description is insufficient for a complete 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?

Schema description coverage is 0%. The description explains the 'rowHeader' parameter but does not clarify the 'collapse' boolean or 'titleMatch' string. Only one of three parameters gains additional meaning from the description.

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

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

The description clearly states the action (expand/collapse) and resource (matrix hierarchy row) with the key identifier (rowHeader). It distinguishes from reading tools like pbi_read_matrix, but does not explicitly differentiate from other sibling tools that might also modify state.

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

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

No guidance is provided on when to use this tool versus alternatives, nor are there any prerequisites or exclusions. The description lacks context for appropriate usage.

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

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

No annotations are provided, and the description does not disclose behavioral aspects such as side effects, permissions, or limitations. For a read-only list operation, the risk is low, but the description fails to add transparency beyond the basic functionality.

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

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

The description is a single sentence that is concise and front-loaded. It provides all necessary information without any extraneous text, earning a perfect 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?

Given the tool's simplicity (no parameters, no output schema), the description is complete. It specifies the action and the output format, meeting all contextual needs for this low-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?

There are no parameters, so no parameter information is needed. The description does not add any parameter semantics, but the schema coverage is 100% (vacuously). Baseline for zero parameters is 4, indicating no missing information.

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

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

The description clearly states the tool lists all report page tabs and specifies the output format as an array of objects with 'name' and 'active' fields. It distinguishes from sibling tools like pbi_goto_page (navigation) and pbi_page_sweep (iteration) by focusing on listing.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The tool's simple nature (no parameters, direct output) makes usage intuitive, but it does not mention alternatives or prerequisites, which is acceptable given the low complexity but leaves room for improvement.

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 transparently explains the heavy cost (10-30s+ per page), the waiting mechanism (canvas-ready cap 30s/page), the recording of loadMs and error scan, and the restoration of the original page. This covers the key behavioral traits adequately.

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

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

The description is concise and well-structured, with the heavy warning placed upfront. Each sentence adds value, covering purpose, constraints, behavior, and output. Minor redundancy could be trimmed, but overall it is efficient.

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

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

Given the complexity and lack of output schema, the description covers the main behaviors and constraints but does not explicitly state what the tool returns or yields (e.g., the recorded data). While it mentions recording loadMs, error scan, and cards fingerprint, the return format is unclear, leaving a small gap.

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

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

Schema description coverage is 0%, so the description must add meaning. It explains that 'pages' are the list of page names to iterate and 'errorScan' controls error scanning. This clarifies the parameters beyond their schema definition, though default values or formats are not detailed.

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

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

The description clearly states the tool's purpose: performing a heavy health sweep by rendering each page, measuring load time, scanning errors, and recording a card fingerprint. It distinguishes itself from siblings like pbi_goto_page by emphasizing its deliberate, heavy nature.

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 advises using the tool as an intentional health sweep with a maximum of 2 pages per call and warns against casual use. However, it does not explicitly name alternative tools for lighter navigation or performance checks, leaving the agent to infer when to use this vs. siblings.

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

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

With no annotations provided, the description bears full responsibility. It discloses that the 'captureQueryFor' parameter clobbers the clipboard and that the tool restores the pane and ribbon after execution. This is helpful behavioral context, although it does not mention whether the tool modifies any data or requires specific permissions.

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

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

The description is extremely concise—two sentences totaling 22 words—with no filler. It front-loads the primary purpose and then efficiently covers the optional parameter and side effects. Every sentence adds value.

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

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

Given the tool's simplicity (one optional parameter, no output schema, no annotations), the description covers most necessary aspects: purpose, side effect, and restoration behavior. However, it does not clarify what the tool outputs (e.g., where per-visual render ms appear) or whether a visual must be selected. A small gap, but overall sufficient.

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

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

The input schema has a single optional parameter with 0% description coverage. The description fully explains this parameter: 'optional captureQueryFor grabs one visual DAX via clipboard (clobbers clipboard).' This adds meaningful semantics beyond the schema's bare type definition, making the parameter's purpose and side effect 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 this tool runs the Performance Analyzer lane and measures per-visual render milliseconds. It uses a specific verb ('Run') and resource ('Performance Analyzer lane'), and the additional detail about per-visual ms makes the purpose unmistakable. While it doesn't explicitly distinguish from siblings, no sibling tool has an obviously overlapping purpose.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention scenarios where this tool is preferable or when to avoid it, nor does it reference other tools like pbi_eval or pbi_baseline. The only usage hint is the optional parameter, but no contextual advice.

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

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

No annotations are provided, so the description carries full burden. It discloses the return format but does not mention side effects, required state (e.g., presence of card visuals on page), error conditions, or idempotency. The description is minimal but not misleading; it adequately conveys the basic behavior.

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

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

The description is a single sentence that is concise, front-loaded with the action, and contains no unnecessary words. It communicates the tool's purpose efficiently.

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

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

Given the tool's simplicity (no parameters, no output schema), the description covers the core behavior. However, it lacks context about when card visuals exist or how to ensure they are present. A more complete description might mention invoking after pbi_visuals or similar dependency.

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

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

There are no parameters (0 params, 100% schema coverage), so no parameter documentation is needed. The description adds no parameter information but is consistent with the schema. Per guidelines, 0 params warrants a baseline of 4.

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

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

The description clearly states the tool parses card visuals and returns a list of dictionaries with title and value. It uses a specific verb ('parses') and resource ('card visuals'), and distinguishes itself from siblings like pbi_read_matrix by focusing specifically on card visuals.

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

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

No explicit guidance on when to use this tool versus alternatives. While the purpose is clear and it's a simple read operation, there is no mention of prerequisites or when not to use it. The presence of sibling tools like pbi_read_matrix suggests different visual types, but no comparison 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, the description carries full burden. It discloses that it reaches a separate page, returns error if view not opened, and is read-only. This adequately informs the agent of behavior.

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

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

Two sentences with no wasted words. Essential information is front-loaded: action, target, constraints, and error case.

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

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

Given no parameters and no output schema, the description covers the tool's purpose, error conditions, and constraints. Slightly lacking explicit statement of success return value, but overall 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?

No parameters exist in the schema, so description does not need to add parameter details. Baseline of 4 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?

Clearly states it reads the DAX query view editor text, specifies the target (daxQueryView CDP target), and distinguishes it from reportView. Also declares itself read-only.

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

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

Provides explicit guidance on when the tool will fail (if view never opened) and instructs to open via the DAX query view tab first. Explicitly states it will not open ribbon views, helping differentiate from other 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?

Describes key behaviors: scrolls virtualized grids and merges by row header. Since no annotations are provided, the description fully covers behavioral traits expected for a read operation, though lacks mention of potential side effects or permissions.

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

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

Single sentence with high information density. Front-loads output structure, then adds behavioral details. 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?

Provides output shape compensating for missing output schema, but critically lacks parameter documentation. Completeness is adequate for a simple tool but falls short given the lack of param descriptions.

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

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

No explanation of the two parameters (index, titleMatch) despite 0% schema description coverage. The description adds no meaning beyond the schema, leaving agents unable to determine how to use these optional 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?

Clearly states verb 'Read' and resource 'matrix/grid'. Specifies output format {columns, rows, ...} and unique behaviors like scrolling virtualized grids and merging by row header. Distinct from siblings like pbi_read_cards.

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

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

Implies usage for reading matrices with virtualized grids, but no explicit guidance on when to use vs alternatives or prerequisites. Missing context on when not to use.

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

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

No annotations are provided, so the description carries full weight. It discloses read-only nature, the error case when view not opened, and that it does not open ribbon views. Gives architectural context (separate page from reportView). Minor omission: doesn't explicitly describe success response format, but can be inferred.

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 dense sentences with no wasted words. Front-loaded with primary action, followed by essential caveats. Excellent 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 tool with no parameters and no output schema, the description covers purpose, prerequisites, error behavior, and read-only nature. Lacks explicit success response but is mostly 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?

Input schema has zero parameters; description does not need to add semantics. Baseline of 4 applies as no information is missing.

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 (read), the target (TMDL view editor text), and distinguishes it from sibling tools like pbi_read_dax_editor by emphasizing it's a separate page and requires prior opening. No tautology.

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

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

The description explains when to use (to read TMDL view text) and when it fails (if view never opened), and instructs to open the tab first. It does not explicitly mention alternatives but the context is clear.

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

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

Despite no annotations, the description extensively discloses behavioral traits: trusted input via page.mouse/keyboard, arbitrary automation risk, best-effort powerBIAccessToken guard, need to restore state after mutations, and setTimeout inside page.evaluate. This exceeds basic expectations.

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 with useful information and front-loaded with the 'escape hatch' purpose. While every sentence earns its place, the length is slightly high; a more streamlined presentation could improve readability.

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

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

Given the tool's low complexity (1 param, no output schema), the description is fully comprehensive: it covers purpose, usage context, behavioral warnings, parameter requirements, and security limitations. No unnecessary omissions.

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% for the single parameter 'code', but the description adds meaningful context: it must be an async arrow/function taking (page), return value is JSON-serialized, and includes a security guard note. This adds value beyond the schema description.

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

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

The description clearly states it runs an async JS function with a live Playwright page, providing real trusted input. It explicitly distinguishes itself from pbi_eval by contrasting with page.evaluate, making the purpose and differentiation precise.

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

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

The description advises use for rediscovery and interactions not covered by canned tools, and warns about unsafe automation and state restoration. While it implicitly favors canned tools when available, it lacks explicit 'when not to use' or direct alternatives beyond pbi_eval.

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

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

No annotations provided, so the description must fully disclose behavior. It mentions the exclusion of favicon errors but does not discuss side effects, permissions, or reliability. The tool appears to be a read-only scan, but this is not stated.

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

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

Two sentences, front-loaded with the main action, no wasted words. The description is concise and efficiently communicates the tool's purpose and key detail.

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

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

Given no parameters and no output schema, the description is mostly complete. It covers the main function and an important exclusion. Minor ambiguity around 'recent' could be clarified, but overall sufficient.

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

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

There are no parameters, so the description does not need to add parameter-level meaning. Baseline score of 4 is appropriate as the description adequately handles the no-parameter case.

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 scans visible visuals for broken/errored surfaces and recent non-benign console errors, with a specific exclusion. This distinguishes it from sibling tools like pbi_screenshot or pbi_read_cards, which have different purposes.

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

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

The description provides context about excluded favicon errors but does not explicitly state when to use this tool versus alternatives. Given many sibling tools, more explicit guidance would improve usability.

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 output location (not repo), return objects ({path}, {clippedTo}, error structure), and matching logic (exact then case-insensitive contains). It does not cover permissions or side effects, but the read-only nature is inferred.

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 conveying all key information. It is relatively concise but could be better structured (e.g., with separate sentences or bullet points) for readability. No extraneous content.

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

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

Given no output schema, the description covers return values ({path}, {clippedTo}, error case) and matching logic adequately. It could mention the output directory is configurable, but overall it provides sufficient context for a screenshot tool with 3 optional parameters.

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

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

Schema coverage is 0%, but the description explains each parameter's purpose: filename (optional), fullPage (optional), visualTitle (clips to matching visual with specific logic). It adds significant meaning, including error handling with candidates list, which is not in the schema.

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

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

The description clearly states it screenshots the reportView page, specifies optional parameters (filename, fullPage, visualTitle), and details clipping behavior. It differentiates from sibling tools like pbi_visuals by referencing the same visual logic for title matching.

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 covers usage (screenshots with optional clipping) but does not explicitly state when to use this tool over siblings, nor does it provide exclusions or alternatives. The agent can infer from context but lacks clear 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 fully discloses behaviors: never sends keystrokes to canvas (historical bug), clears via input's own value, polls for filtered items, returns specific shape, and notes mutation of filter when pick is used. This is comprehensive and builds trust.

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

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

The description is front-loaded with the main action and contains valuable behavioral details, but it is somewhat lengthy. Every sentence adds meaning, but there is minor redundancy (e.g., 'never sends keystrokes' could be integrated). A good balance of completeness and conciseness.

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

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

Given the tool's complexity (3 params, no output schema, no annotations), the description covers return values, mutation effects, and edge cases (focus abort). It lacks explanation for the 'container' parameter, but overall provides sufficient context for an AI agent 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 input schema has three parameters (query, pick, container) with zero description coverage. The description explains query and pick (including matching logic), but container is not described, leaving a semantic gap. Though the description adds value for two parameters, the missing container reduces effectiveness.

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 types into a slicer's search box and optionally clicks a matching result. It uses specific verb 'type' and resource 'slicer search box', distinguishing it from siblings like pbi_set_slicer (which sets slicer state) and pbi_type (general typing).

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

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

The description explains when to use the tool (to search and pick slicer items) and provides behavioral details such as aborting if focus fails and clearing via input's value. However, it does not explicitly state when not to use it or compare with alternatives like pbi_set_slicer, which would strengthen 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 must disclose all behaviors. It reveals that button kind returns aria-pressed before/after and item kind returns a fresh state probe, but does not mention side effects, destructive potential, or error conditions.

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

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

The description is a single sentence, front-loaded with the action. However, it uses parentheses and could be restructured for clarity. Still, it earns its place with no unnecessary words.

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

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

Given two parameters, no output schema, and no annotations, the description provides basic understanding but omits details about return types, error cases, and state changes. It is adequate but incomplete for a full contextual picture.

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

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

Schema coverage is 0%, so description must clarify parameters. It explains the 'kind' parameter with its two enum values and the different returns, but fails to describe the 'value' parameter, leaving ambiguity about its format or meaning for each kind.

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 sets a slicer and distinguishes two specific kinds ('button' and 'item'), each with distinct behavior and return values. This provides a specific verb-resource-action and differentiates the tool's two modes.

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 each kind (button vs item) but does not explicitly mention when not to use this tool or compare it to siblings like 'pbi_search_slicer' or 'pbi_click'. Lacks explicit usage context.

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

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

No annotations provided, but description fully discloses behavior: read-only, returns indented lines of ARIA snapshot, selector scoping to sub-tree, filter regex with indent preservation, maxLines cap with default 400. Clearly labeled 'Read-only' at end.

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 concise sentences: first states purpose and analogy, second describes output format, third explains all three parameters with defaults. Front-loaded and no unnecessary words.

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

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

Given no output schema, description sufficiently explains return format (lines with roles and accessible names, indented). All parameters are described with defaults and behavior. Maps well to tool complexity and sibling context.

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

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

Schema coverage is 100% (baseline 3), but description adds value: explains filter keeps matching lines with their indent, gives default values for maxLines (400) and selector ('body'), and clarifies selector roots the snapshot.

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?

Explicitly states it returns accessibility-tree snapshot of reportView page, comparable to browser_snapshot, for structure discovery when selectors drift. Clearly differentiates from siblings like pbi_deep_snapshot by specifying it returns ARIA snapshot with roles and accessible names.

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 context for when to use: 'for structure discovery when a selector drifts.' Although it doesn't explicitly list alternatives or when not to use, the use case is clearly implied, guiding the agent 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?

No annotations are provided, so the description carries the full burden. It lists return fields but does not disclose behavioral traits like read-only nature, side effects, or rate limits. The name 'state_probe' implies a read operation, but this is not explicitly confirmed.

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 line, which is concise but could be more front-loaded with a clear action verb. The list of fields in braces is efficient, but a more structured sentence would improve clarity.

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 output schema, the description adequately explains the return fields. However, it lacks context on when to use this probe compared to other state-related tools, and it does not describe the behavior of a 'batched scorecard' in detail.

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

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

With zero parameters, the baseline is 4. The description adds meaning by listing the output fields (activePage, toggles, etc.), which compensates for the absence of a return schema. This tells the agent what to expect from the tool.

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

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

The description includes a specific verb ('Batched scorecard') and lists concrete state fields, distinguishing it from sibling tools like pbi_snapshot or pbi_read_cards which focus on single aspects. However, it does not explicitly state a verb like 'get' or 'retrieve', leaving some ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives such as pbi_snapshot or pbi_deep_snapshot. There is no mention of use cases, prerequisites, or exclusions.

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

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

With no annotations, the description carries the full burden. It discloses the connection behavior, the specific status fields reported, and the fallback return value. This provides sufficient transparency for a read-only status check.

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 key action and lists details efficiently. No extraneous information.

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

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

For a tool with no parameters and no output schema, the description covers input (none), behavior (connecting over CDP, reporting specific fields), and output format (including failure case). This is 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?

No parameters are defined, so baseline score is 4. The description does not need to add parameter information.

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

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

The description clearly states the tool connects to Power BI Desktop over CDP and reports status, listing specific fields like build, title bar, active page, page count, zoom, canvasReady. This differentiates it from sibling tools that perform more specific actions.

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

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

The description provides clear context that the tool is used to check status and connectivity, including the return format when unreachable. However, it does not explicitly mention when not to use this tool or suggest alternatives.

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

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

No annotations exist, so description carries full burden. It discloses target resolution order, focus behavior, abort on focus failure, clear and submit mechanics, return value shape, and a clear warning about state mutation. No contradictions.

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

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

Description is concise and front-loaded with purpose. It efficiently packs technical details, though could benefit from structured bullets for clarity. No wasted sentences.

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

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

Covers purpose, target resolution, clear/submit behaviors, return value, and mutation warning. Missing some edge cases (e.g., interplay of clear and submit, behavior with empty text) but given complexity, it is largely complete for effective use.

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

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

Schema coverage is 0%, so description must compensate. It explains clear, submit, selector, and ariaLabel behaviors in context. The required 'text' parameter is obvious from tool name but could be more explicit about appending vs replacing. Overall, adds significant meaning beyond bare schema.

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

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

Description clearly states the tool types text into editable elements via trusted keyboard input. It specifies target element types and resolution order, distinguishing it from sibling tools like pbi_click which handle clicks.

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

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

Usage is implied by purpose but no explicit comparison to alternatives or conditions for use. The warning about mutating report state provides some context for when to use (testing), but does not state when not to use or suggest alternative tools.

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

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

The description fully discloses behavioral traits: it explains the heuristic for 'type', the sources for 'title', the rounding of coordinates, and the reuse of the broken-visual scan for 'hasError'. It also declares the tool as 'Read-only', which is crucial since no annotations are 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 extremely concise at two sentences, front-loaded with the output format, and efficiently explains each field. No superfluous 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?

Despite lacking output schema, the description thoroughly explains the output format and each field, covering edge cases like null type. It could mention behavior on empty pages or error states, but overall it is sufficiently complete for a parameterless tool.

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

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

The tool has no parameters, and the input schema is empty with 100% coverage. The description provides no parameter information, but baseline is 3 as per rules for high schema coverage. The description focuses on output, which is not part of this dimension.

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

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

The description explicitly states the tool lists every visible visual on the active page with a detailed output format including all fields. It distinguishes from sibling tools like pbi_snapshot or pbi_read_cards, which have different purposes.

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

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

The description clearly states what the tool does but does not provide explicit guidance on when to use it versus alternatives. Usage is implied from the output description, but no direct comparison or exclusion criteria are given.

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

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

No annotations are provided, so the description must fully disclose behavior. It mentions polling and return format but omits critical details such as polling interval, default timeout, behavior when both text and textGone are specified, and error conditions.

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

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

The description is extremely concise, conveying core functionality in a single sentence plus return type. No extraneous information, 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?

Given 3 parameters, no output schema, and no annotations, the description leaves significant gaps: no explanation of mutual exclusivity of text/textGone, no default timeout, no behavior on timeout or errors. Insufficient for an agent to use reliably without additional inference.

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

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

Schema description coverage is 0%. The description explains the purpose of text and textGone parameters. However, timeoutMs is not mentioned despite being a parameter, leaving its role unclear. Partial compensation but missing one parameter.

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 polls body innerText until a specified text appears (text) or disappears (textGone), and returns a result object. It distinctly describes a waiting/polling utility, differentiating it from sibling tools that perform clicks, queries, or other actions.

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

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

The description implies usage when waiting for text conditions but does not explicitly state when to use versus alternatives like pbi_state_probe. No guidance on when not to use or prerequisite conditions.

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