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

Adds context beyond annotations: describes status output format (single vs array with isDefault), stop behavior without appIdentifier (stops all), and connection via WebSocket. Annotations indicate idempotentHint=true, which description complements by explaining idempotent 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 front-loaded purpose, then action details, then usage notes. Slightly verbose but every sentence adds value, including alternatives. Could be trimmed without losing substance.

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 all important aspects: required before other tools, explains status output format, mentions WebSocket connection, sets context within sibling tools. No output schema, but description adequately explains return 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?

All parameters have descriptions (100% coverage). Description adds value: host falls back to env vars, port defaults to 9223, appIdentifier only used with stop. Explains the identifier field uniquely identifies apps.

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 the tool is for Tauri apps only, managing automation sessions with start/stop/status actions. It distinguishes itself from sibling tools by specifying it's for Tauri automation and not for browser (Chrome DevTools MCP) or Electron apps.

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

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

Explicitly states when to use: required before using any webview_* or ipc_* tools. Also specifies when not to use: for browser automation or Electron apps. Provides details on concurrent connections and default app behavior.

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

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

Annotations already indicate readOnlyHint=true and idempotentHint=true, so the tool is safe. The description adds useful context about the step-by-step guidance and the prerequisite to examine the project and ask permission, but this aligns with the annotations and doesn't reveal any unexpected 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 three well-structured sentences: purpose, usage conditions, and an important note. Every sentence serves a purpose, with zero wasted words.

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

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

Despite lacking an output schema, the description clearly states what the tool returns ('step-by-step guidance') and the key behavioral requirement (examine project, ask permission). Annotations cover safety, and the sibling context shows this is a distinct setup help tool.

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

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

The tool has zero parameters, so the baseline is 4. The description appropriately avoids parameter discussion and focuses on usage context, which is sufficient given no input values are needed.

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 'Get instructions for setting up or updating the MCP Bridge plugin in a Tauri project', providing a specific verb and resource. It distinguishes itself from sibling tools like driver_session by listing explicit scenarios (connection failure, plugin detection, user request).

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

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

The description explicitly enumerates three conditions under which the tool should be called: driver_session failure, detecting outdated/missing plugin, or user asking about setup. It also notes that the returned instructions require the agent to examine the project and ask permission before changing anything.

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

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

Annotations (readOnlyHint=false, destructiveHint=false) indicate a non-destructive write operation. The description adds context beyond annotations by stating the prerequisite of an active driver session and the Tauri-specific nature, which helps the agent understand the behavioral context.

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

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

The description is concise: a single sentence broken into three clear statements. It is front-loaded with the scope (Tauri Apps Only) and each sentence serves a purpose—describing the action, prerequisite, and alternative.

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

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

The description covers prerequisite (driver session), scope (Tauri), and alternative (Chrome DevTools). It does not mention return value or side effects, but for an emit tool, the return is likely trivial. It is sufficiently complete for its complexity and available 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?

Schema description coverage is only 33% (only appIdentifier has a description). The description does not elaborate on parameter meanings or usage, leaving the eventName and payload parameters unexplained. It relies on the schema which lacks descriptions for most parameters.

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

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

The description clearly states the tool's purpose: emitting a Tauri event for testing event handlers. It specifies Tauri-only scope and distinguishes from DOM events, aligning well with the sibling tools list which includes webview_dom_snapshot and webview_execute_js for DOM operations.

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

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

The description provides explicit usage guidance: 'Requires active driver_session' and 'For browser DOM events, use Chrome DevTools MCP instead.' This tells the agent when to use this tool and when to choose an alternative.

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

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

Annotations already declare the non-read-only, non-destructive, non-open-world profile, and the description adds real behavioral context: plugin:mcp-bridge|* commands route through the bridge while others go through window.__TAURI_INTERNALS__.invoke, and Tauri capability rules stay enforced. It does not describe return payloads or failure modes, minor given the routing detail it supplies.

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?

Front-loads the critical '[Tauri Apps Only]' qualifier and keeps the routing/output distinctions compact. Dense in clauses but essentially no filler; each clause carries routing or scoping 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 non-trivial execution tool with no output schema it covers the important behavioral constraints (driver_session, capability enforcement, routing). The remaining gap is that the 'args' parameter is unexplained, but everything an agent needs to select and route the call 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?

Schema coverage is 50%: windowId and appIdentifier are documented, but 'command' and especially 'args' are bare. The description clarifies the plugin:mcp-bridge|* command naming convention, but says nothing about the args structure, leaving a required-adjacent parameter undocumented in both places.

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

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

States a specific verb+resource (execute Tauri IPC commands / invoke Rust backend functions) and gates scope up front with '[Tauri Apps Only]'. It explicitly distinguishes itself from browser APIs and Electron IPC, so an agent can separate it from siblings like webview_execute_js without opening any schema.

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

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

Gives a clear when-to-use condition (Tauri apps, active driver_session required) and a when-not (not browser APIs, not Electron IPC). The alternative is only gestured at ('use appropriate tools for those frameworks') rather than named, which is the one gap keeping it from a 5.

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

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

Adds key behavioral context beyond annotations: requires active driver_session, Tauri-only scope. Annotations already declare readOnlyHint=true, no contradiction.

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

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

Two concise sentences: first states purpose and scope, second adds prerequisite and use case. No wasted words, 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 readOnlyHint annotation and simple schema (1 optional param), description covers all needed context: purpose, prerequisite, use case. No output schema, but return value is implied as state info. Complete for this tool.

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

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

Schema covers 100% of parameters with description. Description does not add extra parameter semantics beyond schema, so baseline 3 is appropriate.

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

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

Description clearly states it gets Tauri backend state with specific items (app metadata, Tauri version, environment). Specifies 'Tauri Apps only' and distinguishes from siblings like webview tools.

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

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

Explicitly states prerequisite 'Requires active driver_session' and use case 'verify you're connected to a Tauri app and get app info'. Could mention when not to use it, but context is clear.

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

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

Annotations already mark readOnlyHint=true, and the description adds critical context about the dependency on ipc_monitor. It also describes the captured content (arguments and responses). Though it doesn't detail error behavior, it sufficiently reveals behavioral traits beyond annotations.

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

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

Three concise sentences, front-loaded with scope and prerequisite, followed by what the tool shows and a clear alternative. Every sentence earns its place with no redundancy.

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

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

Given no output schema, the description adequately explains what is returned (commands, events, arguments, responses). It also notes the required monitor state. Could be slightly more complete with error handling or data structure details, but sufficient for a read-only retrieval tool.

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

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

Schema coverage is 100% with clear descriptions for both parameters (filter, appIdentifier). The tool description does not add additional parameter semantics beyond what the schema provides, so it meets the baseline without extra value.

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

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

The description clearly states the tool is for capturing Tauri IPC traffic, specifies it requires ipc_monitor started, and explains what it shows (commands, events, arguments, responses). It also distinguishes from browser network requests, making the purpose unambiguous.

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

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

Explicitly mentions prerequisite ('requires ipc_monitor started') and provides an alternative tool for browser network requests ('use Chrome DevTools MCP instead'), giving clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare the safe/idempotent profile (destructiveHint=false, idempotentHint=true), so the description adds value by disclosing scope: it captures invoke() calls via window.__TAURI__.core and excludes bridge-internal commands (plugin:mcp-bridge|*). It does not describe what 'stop' does to buffered captures or how captured data is retrieved, leaving a small gap.

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

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

Dense and front-loaded: the domain constraint leads, prerequisites follow, then capture scope, then the alternative. Every clause carries information and nothing is redundant.

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 exists, yet the description never explains how captured calls are surfaced (presumably via ipc_get_captured), which an agent needs to complete the start/monitor/retrieve workflow. Otherwise prerequisites, scope, and exclusions are sufficient for a 2-parameter tool.

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

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

Schema description coverage is 100%, so the schema already documents both 'action' (start/stop enum) and 'appIdentifier'. The description adds no parameter-level meaning beyond that, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Monitor Tauri IPC calls between frontend and Rust backend') and immediately marks the domain with '[Tauri Apps Only]'. An agent can distinguish it from siblings like ipc_execute_command or ipc_get_captured without opening the schema.

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

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

Gives clear prerequisites ('Requires active driver_session') and a routing exclusion ('for browser network monitoring, use Chrome DevTools MCP'). It does not explicitly contrast with the closest siblings (ipc_get_captured, ipc_execute_command), so it stops short of full alternative-routing guidance.

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

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

Annotations already indicate readOnlyHint=true. The description adds value by specifying the tool's scope (Tauri mobile apps only), but does not describe the return format or behavior beyond that.

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, no wasted words. Front-loads the verb and resource, then provides usage constraints.

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

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

For a zero-parameter tool with no output schema, the description provides sufficient context: what it does and when to use it. Could mention that it returns a list, but not critical.

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?

Tool has zero parameters, so schema coverage is 100%. Description doesn't need to add parameter info. The baseline is 4, and description meets that by providing context.

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

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

The description clearly states it lists Android emulators/devices and iOS simulators, specifically for Tauri mobile development. This distinguishes it from sibling tools which focus on drivers, IPC, or webview operations.

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

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

Explicitly states when to use (Tauri mobile development) and when not to use (desktop-only or web projects). Provides clear decision criteria.

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

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

Annotations already cover the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=true), so the bar is lower. The description adds real context the annotations cannot: the driver_session prerequisite and the plugin-version-dependent error behavior for focus/minimize/maximize.

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?

Front-loads the Tauri-only scope, then a scannable per-action breakdown, then prerequisites and the alternative tool. Every sentence carries distinct information with no filler.

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

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

No output schema exists, but the description sketches what 'list' and 'info' return and covers prerequisites, version gating, and the browser alternative. Nothing needed to call any of the six actions correctly is missing.

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

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

Schema description coverage is 100%, so each parameter (width, height, logical, windowId, appIdentifier) is already documented. The description adds only marginal hints ('requires width/height', 'logical pixels by default') that duplicate the schema, making the baseline 3 appropriate.

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

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

States a specific verb+resource ('Manage Tauri windows') and enumerates all six actions with their effects, so an agent knows exactly what each call does. The '[Tauri Apps Only]' prefix and the 'For browser windows, use Chrome DevTools MCP instead' line cleanly separate it from the webview_* siblings.

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

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

Explicitly gives the prerequisites (requires active driver_session), the version constraint for desktop-only actions (tauri-plugin-mcp-bridge 0.13.0+), and the alternative to use for browser windows. When-to-use and when-not-to-use are both stated.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds a real operational prerequisite (active driver_session required for console logs) beyond the structured data, though it says nothing about truncation behavior, which the schema covers instead.

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 bracketed platform scope is front-loaded, and the source list is compact and scannable. The trailing "at any level" phrase is mildly redundant filler, keeping it out of 5 territory.

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 nine-parameter tool with high schema coverage and no output schema, the description covers source semantics and the key prerequisite. Missing only return-shape/pagination context, which the schema's maxChars descriptions partially absorb.

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 89%, so the schema already documents all nine parameters including enums and truncation semantics. The description's source enumeration largely repeats the schema's own source description and adds no syntax or default details for level, lines, or maxChars.

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

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

States a specific verb and resource (read logs), scopes it ([Tauri Apps Only]), and enumerates the four sources with their meanings. An agent can distinguish it from sibling log-ish tools like ipc_get_captured or ipc_monitor without opening either schema.

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

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

"Use for debugging Tauri app issues at any level" gives clear usage context, and the driver_session prerequisite for the console source is spelled out. It stops short of naming an alternative for non-webview log needs or stating when NOT to use it, so it earns a 4 rather than a 5.

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

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

Annotations already indicate readOnlyHint=true, so the description is not required to repeat that. It adds valuable behavioral context: requires an active driver_session, targets the only connected app or requires appIdentifier for multi-app scenarios, and describes output as YAML representations. No contradictions with annotations.

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

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

Single paragraph of 5-6 sentences, front-loaded with the main purpose, then organized by type, selector usage, and targeting. Every sentence adds value without redundancy. Perfectly sized for an AI agent to quickly grasp the tool's capabilities.

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 (5 params, 1 required, no output schema), the description adequately covers purpose, types, usage scenarios, scoping, targeting, and strategies. It lacks an explicit description of the return format beyond 'YAML representation', but for a read-only snapshot tool, this is sufficient. Minor omission: no example output or error conditions.

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 beyond the schema by explaining the two types in detail, including the analogy to Playwright's aria snapshots, and elaborating on the strategy parameter (e.g., fallback to placeholder, aria-label, title). This provides richer context for parameter selection.

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 it gets a structured DOM snapshot of a Tauri webview, with two distinct types (accessibility and structure) that serve different purposes. It distinguishes itself from siblings like webview_find_element and webview_get_pointed_element by focusing on full-tree snapshots rather than individual element queries.

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

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

Description provides explicit use cases for each snapshot type: 'understanding UI semantics, finding interactive elements, or accessibility testing' for accessibility, and 'understanding page layout, debugging CSS selectors, or locating elements by class/ID' for structure. It mentions prerequisites (active driver_session) and scoping via selector. However, it does not explicitly mention when NOT to use this tool or alternative sibling tools for more targeted queries.

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

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

Annotations only supply safety hints (readOnlyHint=false, destructiveHint=false, openWorldHint=false); the description carries the real behavioral load. It discloses the auth/session prerequisite, the execution environment ('Has access to window.__TAURI__'), return-value constraints (JSON-serializable, IIFE requirement), and error semantics (timeouts identify the failing layer: transport, script self-race, or Rust eval). This is substantial context beyond structured fields.

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

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

Front-loaded with the scope tag and core action, and nearly every sentence earns its place (prerequisite, IIFE, timeout, targeting, alternative). It is somewhat dense at nine sentences in one block, and the IIFE example is repeated verbatim from the schema description, a minor redundancy.

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

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

There is no output schema, so the description correctly covers return handling (JSON-serializable values, IIFE for functions), timeout behavior, prerequisites, and app targeting. An agent has everything needed to invoke this correctly without opening other tools.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds semantics the schema lacks: it explains timeout error behavior (which layer timed out) and the default targeting logic for appIdentifier when multiple apps are connected. The IIFE note duplicates the script field's schema description rather than extending it.

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

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

States a specific verb and resource ('Execute JavaScript in a Tauri app's webview context') with an explicit scope qualifier ('[Tauri Apps Only]'), so the domain is unambiguous. It does not, however, explicitly contrast with the sibling ipc_execute_command, which is the nearest adjacent capability; the only alternative named (Chrome DevTools MCP) is not a sibling 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?

Gives a prerequisite ('Requires active driver_session'), targeting rules ('Targets the only connected app, or the default app if multiple are connected', plus appIdentifier for a specific app), and an explicit exclusion/alternative ('For browser JS execution, use Chrome DevTools MCP instead'). All routing decisions an agent needs are stated.

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

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

Annotations only declare readOnlyHint and openWorldHint, yet the description discloses much more: the active driver_session requirement, targeting behavior (only connected app, default app when multiple, appIdentifier override), the text-strategy matching preferences (exact over substring, innermost, interactive ancestors), and full return shape. This is deep behavioral context beyond structured fields.

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

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

Front-loaded with scope, then routing guidance, strategy behavior, and return shape. Dense and largely waste-free, though the long enumeration of return fields is somewhat list-like and could be tightened; every sentence still carries 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?

No output schema exists, so the description carries the return-value burden and does so thoroughly (totalMatches, returned, per-match fields). Combined with usage routing, prerequisites, and targeting rules, it is complete for a 9-parameter tool.

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

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

Schema coverage is 100%, so the baseline is 3; the description nonetheless adds meaning by explaining how the strategy parameter changes selector interpretation and how ref IDs work across all strategies, plus text-strategy intent. It stops short of detailing nth/limit/windowId tradeoffs, which remain schema-only.

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

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

States a specific verb+resource (find elements in a running Tauri app's webview) and enumerates the data returned (geometry, text, accessible name, attributes, visibility, computed styles). The [Tauri Apps Only] prefix and the explicit 'use Chrome DevTools MCP instead' carve out scope against siblings.

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

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

Explicitly routes the agent: 'Use this instead of webview_execute_js for querySelector, getBoundingClientRect, textContent, and getComputedStyle reads,' names the driver_session prerequisite, explains app-targeting defaults, and points browser/docs work to Chrome DevTools MCP. Both when-to-use and when-not are covered.

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

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

The description adds behavioral context beyond annotations: it requires prior user interaction from Alt+Shift+Click, returns an annotated screenshot, and targets specific apps. Since annotations only provide readOnlyHint=true and openWorldHint=false, the description fully compensates and explains the non-obvious requirement of prior pointing.

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 at 5 sentences with no wasted words. It front-loads the core function and provides all necessary context efficiently. Every sentence adds value, making it easy for an agent to parse quickly.

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

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

The description covers prerequisites (Alt+Shift+Click, active driver_session), return type (rich metadata + annotated screenshot), and targeting logic. While no output schema exists, it references a sibling tool for return structure. This is sufficient for a tool with straightforward parameters and no nested objects.

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

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

Schema coverage is 100% with both parameters already described. The description does not add new semantics beyond what the schema provides for windowId and appIdentifier. Baseline 3 is appropriate since the description adds minimal parameter-specific detail.

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

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

The description clearly states the tool retrieves element metadata after a user points via Alt+Shift+Click, specifying it is Tauri-only and contrasting with webview_select_element. The verb 'retrieves' and resource 'element metadata' are specific, and the context distinguishes it from sibling tools.

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

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

The description explicitly says when to use: after Alt+Shift+Click, and notes it requires an active driver_session. It also mentions targeting the only connected app or default, and that an appIdentifier can be specified. This provides clear guidance on when to call this tool versus alternatives like webview_select_element.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the agent already knows this mutates local UI but is not destructive or open-world. The description adds real behavioral context beyond that: the driver_session prerequisite and the error-on-ambiguity behavior when a text selector matches multiple elements.

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?

Front-loaded with the environment restriction and the core action list, then layers selectors, the nth rule, and prerequisites. The action list is repeated against the enum and the 'Supported actions' enumeration is somewhat redundant, but no sentence is wasted.

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

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

For a 15-parameter mutation tool with annotations and no output schema, the description covers environment scope, prerequisites, selector semantics, and the key disambiguation rule. Coordinate/swipe/duration details live in the schema, which is acceptable given 100% coverage, though it could note the return behavior of interactions.

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

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

Schema description coverage is 100%, so all 15 parameters are already documented, including nth, strategy fallbacks, duration defaults, and coordinate semantics. The description restates the nth disambiguation rule and adds only the error behavior on ambiguous matches, which is marginal value over the schema.

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

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

States a specific verb set (click, hover, scroll, etc.) and resource (Tauri app webview) in the first sentence, and immediately scopes the tool with '[Tauri Apps Only]'. An agent can distinguish it from webview_keyboard and webview_execute_js without opening the schema.

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

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

Explicitly states the environment constraint (Tauri only), the prerequisite ('Requires active driver_session'), and the alternative for the non-applicable case ('For browser interaction, use Chrome DevTools MCP instead'). This is exactly the when/when-not/alternatives pattern.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so safety is partly covered; the description adds useful context beyond that — session prerequisite, targeting resolution rules (only connected app, else default), and appIdentifier semantics. It stops short of stating effects like whether existing field content is overwritten or whether focus is required.

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

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

Four tight sentences, front-loaded with the platform constraint, followed by targeting rules and the alternative. No filler, though the selector/strategy sentence duplicates schema detail and could be dropped.

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 nine-parameter mutation tool with no output schema, the description covers platform scope, prerequisite session, target resolution, and the browser alternative. Remaining gaps (post-typing state, error behavior) are minor given the schema is fully documented.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters including strategy fallbacks and nth semantics. The description largely restates the selector/strategy relationship already present in the schema, adding only the "(for 'type' action)" scoping, which is also in the schema. Baseline 3 applies.

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

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

States a specific verb and resource ("Type text or send keyboard events") scoped precisely to Tauri apps, plus the bracketed platform restriction up front. This distinguishes it immediately from generic siblings like webview_interact and from the browser alternative it 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?

Gives a clear prerequisite ("Requires active driver_session") and an explicit out-of-scope redirect ("For browser keyboard input, use Chrome DevTools MCP instead"). It does not, however, differentiate itself from webview_interact, a sibling that may also perform webview input.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the bar is lower, yet the description still adds real behavior: the driver_session prerequisite and the fact that only the visible viewport is captured. It also explains the app-targeting resolution rule (only connected app, or default app if multiple). It does not surface the interactive OS screen-sharing permission prompt path, leaving that to the schema.

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

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

Front-loaded with the scope constraint and precondition, then the exclusions. Every sentence carries routing or behavioral information; nothing is padded.

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

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

For a zero-required-parameter, no-output-schema capture tool, the description covers scope, prerequisite, targeting resolution, and exclusions. The only omission is what the call returns, but the schema's filePath description ('instead of returning as base64') already covers output form.

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

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

Schema description coverage is 100%, and every parameter (format, quality, filePath, maxWidth, windowId, allowScreenCapture) is documented in the schema itself. The description's appIdentifier note ('port or bundle ID') largely restates the schema's own text, so it adds little beyond the baseline.

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

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

States a specific verb ('Screenshot') and resource ('a running Tauri app's webview'), immediately scoped by '[Tauri Apps Only]'. It also explicitly rules out the two nearest alternatives (Chrome DevTools MCP for browsers, Electron apps), so the agent can distinguish it from everything in the sibling list.

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

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

Gives an explicit precondition ('Requires active driver_session') and names when NOT to use it ('For browser screenshots, use Chrome DevTools MCP instead. For Electron apps, this will NOT work'). This is textbook when/when-not/alternative routing.

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

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

Annotations provide readOnlyHint=true, so no contradiction. The description adds behavioral context: requires driver_session, targets connected apps, and returns detailed element data. It doesn't detail all side effects but is adequate given annotation coverage.

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

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

The description is four sentences with clear front-loading: core purpose first, then return details, then prerequisites and targeting. No redundant information.

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

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

For a tool with 3 optional parameters and no output schema, the description covers the interaction flow, return data, and targeting. Missing error handling or edge cases, but sufficient for an agent.

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

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

Schema coverage is 100%, so baseline is 3. The description reinforces appIdentifier usage but doesn't add new meaning beyond the schema descriptions. No extra semantics needed.

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 activates a visual element picker overlay for Tauri apps, returning rich metadata and an annotated screenshot. This distinguishes it from siblings like webview_find_element (programmatic selection) and webview_get_pointed_element (point-based).

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 specifies prerequisites (active driver_session) and targeting rules (connected app, default app, appIdentifier). It doesn't explicitly exclude alternatives, but the context is clear enough for an agent to decide when to use this visual picker.

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

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

Annotations already declare readOnlyHint=true, so the description does not need to emphasize safety. It adds transparency by detailing the waiting behaviors (selector strategies, IPC events, timeout) and the targeting logic (only connected app, default app). No destructive side effects implied. Slight gap: no mention of timeout behavior on failure.

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 six sentences, each serving a distinct purpose: purpose, strategy details, prerequisites, targeting, appIdentifier clarification, and alternative tool. It is front-loaded with the primary action, and no sentence is redundant. Efficiently covers important aspects without excess.

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 lack of output schema, the description does not explain return values, but for a wait tool the return is likely straightforward (success/failure). It covers major operational details (strategies, targeting, prerequisites). Missing explicit mention of timeout behavior (e.g., throws on timeout). Still, it is nearly complete for a read-only 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. The description adds context like 'When type is selector, supports CSS (default), XPath, and text strategies' and explains appIdentifier targeting. However, it largely reiterates schema descriptions without adding significant new meaning beyond clarifying defaults and strategies.

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

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

The description starts with a clear verb+resource: 'Wait for elements, text, or IPC events in a Tauri app.' It explicitly states the app scope ('Tauri Apps Only') and distinguishes from browser waits by directing to Chrome DevTools MCP. This effectively differentiates it from sibling tools.

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

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

The description provides explicit guidance on when to use this tool: for waiting in Tauri apps, and when not to: for browser waits, refer to 'Chrome DevTools MCP'. It also explains prerequisites (requires active driver_session) and targeting (default app or specify appIdentifier).

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