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

The description discloses that the session is detached (not terminated) on close, which is helpful. However, it does not explain the impact on the currently active session when attaching (e.g., whether the previous session is automatically detached). With only destructiveHint=false in annotations, the description carries the transparency burden and falls short of full clarity.

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, direct, and free of fluff. It communicates the key action and a critical behavioral note without redundancy.

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

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

The description, combined with the schema, covers the essential aspects of the tool: purpose, key behavior (single active session, non-terminating close), and parameter nuances. However, it does not mention when to choose this over alternatives (like start_session) or how the prior active session is handled, leaving a slight gap in overall context.

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

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

The description adds meaningful context beyond the schema: it clarifies that 'capabilities' are used only for local command registration and not sent to the remote endpoint, explains the default for webdriverConfig, and notes that Electron attachment is unsupported. All parameters are described in the schema, and the description enhances understanding of ambiguous fields.

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

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

The description clearly states the tool attaches to an existing remote WebDriver/Appium session by ID, and explicitly notes it does not create a new session. This distinguishes it from start_session and other session-related tools.

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

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

The description implies when to use it (when you have an existing session ID) and mentions the 'only one session active at a time' constraint, but does not explicitly contrast with start_session or close_session. The context is clear enough, but a direct 'use when' statement would improve 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?

The description discloses that clicking may trigger navigation, form submission, or modals — side effects not implied by the destructiveHint=false annotation. It also reveals the default timeout (3000ms) and the wait/scroll behavior, adding valuable context beyond structured 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 sentences, each earning its place: the core action, the side effects, and the platform-specific caveat with alternative. Front-loaded with the action, no redundancy or fluff.

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

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

For a tool with 3 parameters, no output schema, and a sibling that must be disambiguated, this description covers the core behavior, potential side effects, platform constraints, timeout default, and alternative routing. Nothing essential is missing for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so parameters are already documented. The description adds the default timeout value, which is not in the schema, and clarifies that scrolling is part of the click behavior (relating to scrollToView). It does not explain each parameter in depth, but the baseline of 3 is raised because the default timeout is extra useful 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 states a specific action (waits, scrolls, clicks) on a web element, and explicitly contrasts with tap_element for iOS, distinguishing it from a sibling. It also implies browser-only usage, so an agent can tell it apart from native 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?

It gives an explicit platform constraint ('Browser sessions only') and names the exact alternative (tap_element) with the condition ('on iOS element.click() is silently ignored'). This is unambiguous guidance for when to use this tool vs its sibling.

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 significant context beyond the destructiveHint annotation: it clarifies detaching preserves state, auto-detach behavior, and side effects on chromedriver and Chrome processes. This helps the agent understand the tool's impact.

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

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

The description is three sentences, concise and front-loaded with the main action. No redundant information, though some details could be more compact.

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

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

The description covers key scenarios (detach, auto-detach, browser attach sessions) and explains side effects. With a simple single parameter and no output schema, this is sufficient completeness.

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

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

Schema coverage is 100%, and the schema already provides a thorough description of the 'detach' parameter. The tool description adds no extra meaning to the parameter, 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?

The description clearly states the tool closes or detaches the current session, using specific verbs ('closes', 'detaches') and the resource ('session'). It distinguishes from sibling tools like start_session or attach_session implicitly, but no explicit differentiation is provided.

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 behavioral nuances for different session types but does not explicitly advise when to use this tool versus alternatives like detach vs. close, or when to prefer a sibling tool.

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

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

The description adds significant behavioral context beyond annotations: it states the operation is irreversible and affects the current browser session. Annotations already indicate destructiveHint=true, but the description elaborates on the permanence and scope, which is valuable for an agent.

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 clearly states the action and scope, the second highlights irreversibility. There is no irrelevant information, and it is front-loaded with the core functionality.

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

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

For a simple tool with one optional parameter and no output schema, the description covers the essential aspects: what it does, how to specify a target cookie, and the irreversible nature. No additional details are necessary for correct invocation.

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

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

Schema description coverage is 100% for the single parameter 'name', which already explains its optional use for deleting a specific cookie. The description does not add new semantic information beyond what the schema provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool deletes cookies, with specific scope ('all or a single cookie by name'). The tool name 'delete_cookies' matches this, and it is easily distinguished from sibling tools like 'get_cookies' which is 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?

The description implies usage for deleting cookies, but does not explicitly state when to use this tool versus alternatives. The parameter guidance (optional name for specific cookie, omit for all) is provided, but no exclusions or prerequisites 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?

Describes coordinate offsets as relative to source element (not absolute), and mobile-only constraint. Annotations only provide destructiveHint=false, so description adds value by disclosing these behaviors. Does not mention duration defaults or whether operation is blocking.

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-loaded with main action. Every sentence adds essential 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?

Covers core behavior, two modes, coordinate clarification, and mobile restriction. Lacks detail on duration default, visibility requirements, and error behavior. No output schema so return value is implied as void.

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. Description adds meaning by clarifying that x/y are offsets from source (not absolute), enforcing exclusivity of targetSelector vs x/y, and stating mobile-only constraint.

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 drags an element to another element or to relative x/y offsets. Distinguishes from sibling tool tap_element by clarifying coordinate system. Mentions mobile-only scope.

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

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

Explicitly states two usage modes (targetSelector or x/y) and contrasts coordinate system with tap_element. Implicitly indicates mobile-only use. Does not cover when to prefer over other sibling tools like scroll or set_value.

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?

Goes beyond annotations (idempotentHint, destructiveHint) by detailing which settings are modified (viewport, DPR, user-agent, touch events), persist behavior, and the ability to list presets or reset. 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?

Four sentences covering purpose, prerequisite, special values, and persistence. No redundancy, front-loaded, and 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?

Covers main action, prerequisites, and behaviors well. Lacks details on error handling or return format (e.g., when listing presets), but sufficient for effective use given the simple parameter.

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

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

Schema coverage is 100% and the schema description already fully explains the parameter (omit to list, pass 'reset', preset names). The tool description repeats this but adds no new parameter-specific details 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?

Description explicitly states it emulates mobile/tablet devices by setting viewport, DPR, user-agent, and touch events. Clearly distinguishes from sibling tools (no other emulation tool present) and adds context like 'Browser-only' and required BiDi session.

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

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

Provides clear context: requires BiDi-enabled session, omit device to list presets, pass 'reset' to restore defaults, changes persist until reset or session close. Does not explicitly mention alternatives, but no direct alternatives exist among siblings.

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

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

Annotations already flag destructiveHint=true, but the description adds valuable context by calling out that this is privileged code execution with access to Electron APIs and emphasizing trust requirements. This goes beyond the annotation by explaining the nature and risk of the operation, though it does not enumerate potential side effects or error behaviors.

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

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

The description is two sentences with no filler. The core function is stated first, and the essential security warning follows immediately. Every word earns its place, and the structure is front-loaded for quick comprehension.

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

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

The description covers the core function and security risk, and the schema covers parameters, but there is no output schema and the description does not explain the return value format or behavior on errors. For a privileged execution tool, an agent might need more clarity on what the `return` produces or how failures surface, so the description is slightly incomplete.

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

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

The schema descriptions already cover both parameters thoroughly: script explains the body and usage of `electron`, `args`, and `return`, and args explains array indexing. The tool description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline for full schema coverage.

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

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

The description explicitly states the action ('Executes arbitrary JavaScript') and the target resource ('in the Electron main process'), making its purpose immediately clear. It also distinguishes itself from the sibling tool `execute_script` by specifying the Electron main process context, so an agent can tell them apart without inspecting schemas.

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 establishes the intended context (Electron main process) and adds a critical caution ('use only with trusted scripts'), which guides usage. However, it does not explicitly name alternatives like `execute_script` for page context or state when not to use this tool, so it stops short of full 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?

With destructiveHint=false, the description expands on behavior: can read/modify DOM, trigger events, terminate apps, run shell commands. It also explains mobile syntax specifics. While not exhaustive (e.g., potential side-effects), it covers key behaviors 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?

The description is front-loaded with purpose and well-structured, but somewhat lengthy. However, every sentence adds value, covering browser/mobile distinctions and alternatives. Could be slightly more concise, but effective.

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

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

Despite lack of output schema, the description covers return value usage ('return' for browser values) and mobile command syntax. It addresses the tool's complexity adequately, though mobile return values are not specified.

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% but description adds context: script parameter explained for both browser and mobile, args parameter detailed for element selectors or command-specific objects. This adds meaning beyond the schema's basic descriptions.

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

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

The description clearly states the tool executes arbitrary JavaScript in browser or Appium mobile commands, specifying distinct use cases. It distinguishes from dedicated tools by advising to use only when no dedicated tool covers the action, making the purpose precise and well-differentiated from 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 states when to use (only when no dedicated tool covers the action) and provides detailed examples for browser vs mobile. It also advises preferring click_element/set_value/get_elements for standard interactions, offering clear 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?

Annotations already provide readOnlyHint and idempotentHint. The description adds value by detailing the content (roles, names, selectors), filtering by ARIA roles, and pagination (limit/offset). There is 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 sentences, front-loaded with the primary purpose, no redundant words. 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 no output schema, the description describes return contents (roles, names, selectors) and covers filtering/pagination. For a simple read-only tool, this is quite complete.

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

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

Schema description coverage is 100%, so baseline is 3. The description mentions filtering by ARIA roles and pagination, which aligns with the schema but adds minimal extra meaning. It does not elaborate beyond what parameters imply.

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 'Returns the page accessibility tree with roles, names, and selectors.' This specifies a specific verb (returns) and resource (accessibility tree), and distinguishes itself from sibling tools like get_elements by mentioning 'Browser-only' and focusing on accessibility roles.

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

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

The description includes 'Browser-only,' which provides clear context for when to use (in a browser session). However, it does not explicitly state when not to use or suggest alternatives among siblings. The context is helpful but not comprehensive.

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 annotations already declare readOnly and idempotent hints, and the description's 'Returns' aligns with a read-only operation. The description adds value by enumerating the possible states, but it does not mention error behavior or side effects, which are already covered by the 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?

The description is a single, concise sentence. It conveys all necessary information without redundancy or unnecessary detail. 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 simple state-checking tool, the description covers the action, the subject (mobile app), the possible results, and a platform constraint. No output schema exists, but the description's enumeration of states effectively communicates the return value. Complete for its context.

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

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

The input schema provides a full description for the single parameter 'bundleId' (including an example). Since schema coverage is 100%, the tool description does not need to add extra parameter context. Baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: to return the current state of a mobile app, listing the possible states. It also specifies 'Mobile-only', which helps distinguish it from web-oriented tools. No ambiguity.

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

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

The 'Mobile-only' note provides a usage constraint. However, it does not explicitly say when to use this tool over alternatives (e.g., when you need to check app installation status). Still, the condition is clear enough for a simple 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?

Annotations already declare readOnlyHint and idempotentHint. Description adds specific behavioral context: mobile-only, returns NATIVE_APP and WEBVIEW_* targets, which adds value 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?

Two sentences, no filler. Front-loaded with purpose, then usage advice. Every word earns its place.

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

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

For a zero-parameter tool with annotations, the description is complete. It explains what is returned, when to use it, and the mobile-only context. No gaps.

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

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

No parameters defined, so baseline 4 per guidelines. Description does not need to add parameter info as schema is empty and coverage is 100%.

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 returns available automation contexts and the active one. Specifies the resource (automation contexts) and action (returns). Differentiates from sibling 'switch_context' by being a discovery 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?

Explicitly advises use before switch_context and notes mobile-only context. Provides clear when-to-use guidance and domain restriction.

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 state read-only and idempotent. Description adds that it returns cookies and can filter by name, plus usage context like auth verification, which goes 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?

Two sentences, no fluff. Every sentence adds value: first states function, second gives usage guidance.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description fully covers purpose, usage context, and behavior. No gaps.

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

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

Schema coverage is 100%, and the description reiterates the parameter behavior (all vs. single cookie). No additional semantic details beyond what the schema provides.

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

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

Clearly states the tool returns cookies (all or by name) and provides specific use cases like verifying auth state, session tokens, or feature flags. Differentiates from write siblings like delete_cookies.

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 advises using the tool after login flows for verification, giving context on when to use. Does not explicitly mention alternatives or when not to use, but the description is clear enough.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the description's main behavioral additions are the return data (selectors, text, bounding boxes) and filtering capabilities. It does not contradict annotations and adds useful context beyond the 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?

The description is two sentences long, front-loading the purpose and return value, followed by a usage hint. Every sentence adds value with no redundancy or fluff.

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

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

Given no output schema, the description adequately indicates the return shape (selectors, text, bounding boxes) and covers the key filtering options. It is complete enough for a read-only tool with optional parameters, though additional details on return format or pagination behavior could be added.

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 100% description coverage, so the baseline is 3. The description groups parameters into high-level concepts (element type, viewport visibility, pagination) but does not add significant new meaning beyond the schema. Minor mismatch: 'element type' is not fully aligned with the 'includeContainers' 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 it returns interactable elements with selectors, text, and bounding boxes, and supports filtering. It distinguishes itself by mentioning when to use it over the native wdio resource, making the purpose specific and differentiated from 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?

It provides a direct usage condition ('Use when the wdio://session/current/elements resource does not return desired elements'), which helps the agent decide when to invoke this tool. However, it does not list explicit exclusions or compare to other sibling tools like get_tabs or get_accessibility_tree.

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 readOnlyHint annotation already signals a safe read operation, and the description adds valuable behavioral constraints: active session scope, mockType default behavior, Electron-specific parameter requirements, and unsupported browser/Appium cases. It does not contradict the annotation and gives enough detail to set 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 purpose is front-loaded in the first sentence, followed by concise usage and limitation notes. Some details repeat the schema descriptions, but the description remains compact and scannable.

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

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

Given that this is a read-only inspection tool with well-documented parameters, the description covers target selection, defaults, required conditions, and unsupported sessions. It does not specify the exact return shape, but the return behavior is implied clearly by the stated purpose.

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 the schema already documents that apiName and funcName are required for electron and that mockType has defaults and limitations. The description reinforces these points but does not add significant meaning beyond the schema.

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

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

The description states a specific action, 'Read current call arguments for a mock', tied to a clear resource and scope ('in the active session'). This clearly differentiates it from sibling tools like mock and manage_mock, which create or modify mocks rather than inspect them.

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

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

The description gives clear practical guidance: use the same target as mock, understand that mockType defaults to browser in WebDriver and is required in Electron, and that Electron mocks need apiName and funcName. It also states unsupported contexts. It does not explicitly name alternatives, but the context is sufficient for correct 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?

The description discloses that it returns a base64 image and that the image is resized and compressed for model context limits, which adds useful behavioral context. The readOnlyHint and idempotentHint annotations already cover safety, and the description does not contradict them.

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

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

The description is a single concise sentence that directly conveys purpose and output format without unnecessary detail. 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?

The description provides enough context for the agent to understand what the tool does and what output to expect. It mentions the return format and processing, which is sufficient for a tool with no parameters and no output schema. Minor details like image format are not essential.

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, so there is no parameter semantics burden on the description. The absence of parameters is already clear from the empty schema, and the description appropriately focuses on behavior rather than inputs.

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 captures a screenshot of the current page or screen and returns a base64-encoded image. The verb 'Takes' and the resource 'current page or screen' make the purpose unambiguous and distinguish it from sibling tools like get_accessibility_tree or get_elements.

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

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

The description implies the tool is for capturing visual state, but it does not explicitly state when to use it versus alternatives or when not to use it. There is no direct guidance on choosing this tool over get_accessibility_tree or get_elements for inspection tasks.

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 and idempotentHint, so the description adds value by specifying the output fields (handle, title, URL, active). This clarifies the behavioral output beyond the 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?

Two sentences with no wasted words. The first sentence provides the core functionality, and the second offers usage guidance. Well-structured and 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 zero parameters and no output schema, the description is fully complete: lists what the tool returns and when to use it. No gaps or missing information.

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; schema coverage is 100%. Baseline score of 4 is appropriate as the description does not need to add parameter details.

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 browser tabs with specific fields (handle, title, URL, active). It uses the verb 'Lists' and specifies the resource, distinguishing it from siblings like switch_tab.

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 'Use before switch_tab to find the target handle or index', providing a clear when-to-use directive and referencing a sibling tool for 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?

The annotations already include idempotentHint=true and destructiveHint=false, which convey key behavioral traits. The description adds that it is a no-op if already hidden and is mobile-only, which are additional behaviors not fully captured by the annotations. This is a good complement to the hints, so a 4 is appropriate.

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 three short sentences that pack in the key information: what it does, when to use it, and edge cases. No fluff or redundancy. It is front-loaded with the primary action and then provides context. This is an exemplary concise description.

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

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

The tool is simple (no parameters, no output schema), and the description covers the essential context: the action, timing, and caveats (no-op, mobile-only). It doesn't mention the return value or error cases, but for a simple UI action, that may not be necessary. The description is complete enough for an agent to use it correctly.

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

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

The tool has no parameters, so the schema coverage is 100% trivially. The description doesn't need to explain parameters, but it could have mentioned that there are no arguments. The description's context about use cases indirectly implies no parameters are needed. Given that there are no params to misinterpret, this is adequate.

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 dismisses the on-screen keyboard on mobile, identifying the resource (keyboard) and action (dismiss). It also adds context about when to use it (after text entry when keyboard obscures elements), which differentiates it from other UI interaction tools. However, it doesn't explicitly name sibling tools that might be confused with it, but the action is specific enough.

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 guidance on when to use the tool: after text entry when the keyboard obscures elements. It also notes that it is a no-op if already hidden and is mobile-only, which helps the agent decide when to call it. It doesn't explicitly say when not to use it (e.g., on desktop), but the mobile-only qualifier covers that.

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 reveals key behaviors beyond annotations: wipes and recreates temporary profile directory each call, spawns a detached Chrome process persisting after server exit, and copyProfileFiles limitations. Annotations only provide destructiveHint=false, so the description adds substantial value.

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 (4 sentences), front-loaded with the main purpose, and each sentence adds necessary information without redundancy. No fluff or extraneous details.

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

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

Given no output schema, the description adequately covers the launch process, including lifecycle (call start_session next). It could mention what the return value is (e.g., success message or port), but for a launch tool, the current information is 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?

Schema coverage is 100%, but the description enriches understanding by explaining mode semantics in plain language and clarifying copyProfileFiles behavior (no sync back). It adds context beyond schema, though schema already describes parameters adequately.

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 launches Chrome with remote debugging enabled, specifying the verb 'launches' and the resource 'Chrome'. It distinguishes between two modes and references sibling tools like start_session, making purpose unambiguous.

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

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

The description explains when to use each mode (newInstance vs freshSession) and the behavior of copyProfileFiles, including a critical caveat that changes do not sync back. It also advises calling start_session after launch. However, it does not explicitly list when not to use the tool or contrast with alternatives like attach_session.

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 readOnly and idempotent behavior. The description adds useful information that provider-specific credentials are read from the environment, providing context beyond the annotations without contradicting them.

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

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

The description is a single concise sentence that conveys the tool's purpose and provider scope without unnecessary detail. 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?

For a simple read-only listing tool with no output schema, the description provides enough operational context: what it lists, which providers it supports, and where credentials come from. It could mention expected result shape, but that is not required given no 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 100% and each parameter already has a description, so the baseline applies. The description adds provider full names and credential sourcing context, but does not meaningfully clarify individual parameters 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?

Description clearly states the action ('List apps uploaded to a cloud provider') and explicitly enumerates the supported providers, distinguishing this from the sibling upload_app 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?

The use case is implied by 'List apps' but there is no explicit guidance on when to use this instead of alternatives such as upload_app, or any exclusions or prerequisites beyond reading credentials from the environment.

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 goes well beyond the destructiveHint annotation by specifying exactly what each action does: clear removes call history, reset also removes configured behavior and queued values, and restore reinstates the original function and releases the mock. This is clear, detailed, and consistent with the annotation.

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

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

The description is compact and front-loaded with the core purpose before moving to constraints and per-action behavior. Three dense sentences convey the necessary information without fluff, and the structured enumeration for Electron actions 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?

The description covers the essential invocation details: required action values, mockType defaults and requirements, Electron parameter dependencies, and unsupported environments. It does not mention output or what happens if no mock exists, but for a state-changing management tool the provided context is largely 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 schema already documents apiName, funcName, and mockType, and the description reinforces the Electron dependency while adding meaning to the action enum by explaining what clear, reset, and restore do. This compensates for the missing per-enum descriptions in the schema, though some duplication with the schema remains.

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 that the tool manages a mock in the active session and details the three actions clear, reset, and restore with their effects. It identifies the resource and scope, though 'manage a mock' is somewhat generic and it does not explicitly contrast the tool with sibling tools like mock or get_mock_calls.

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

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

The description provides concrete usage context: mockType defaults to browser in WebDriver, is required in Electron, Electron mocks need apiName and funcName, browser mocking is not implemented, and Appium sessions are unsupported. It gives clear exclusions and prerequisites, but does not explicitly tell an agent when to choose this tool over sibling tools.

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

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

Annotations only supply destructiveHint=true, so the description carries the burden of behavioral context. It adds session scoping, default mockType behavior, unsupported session types, the persistence of history across repeated calls, and queued once-value semantics. No contradiction with the annotations exists.

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 sentences, front-loaded with the core purpose, and every sentence earns its place by adding a constraint, a requirement, or a usage nuance. There is no repetition of the schema or filler.

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

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

The description covers defaults, unsupported cases, required parameter combinations, and cumulative behavior, which is strong for a tool with five optional-looking parameters. The main gap is that it does not state what the call returns, and its relationship to manage_mock remains implicit.

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%, but the description meaningfully enriches parameter understanding: it explains mockType defaults, conditional requirements for apiName/funcName in Electron sessions, behavior enum semantics, and async API guidance. This goes well beyond the baseline expected from complete 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 opens with 'Configure a session-scoped mock,' giving a specific verb, resource, and scope that goes well beyond the bare name 'mock' and title. It clearly defines what the tool does, though it does not explicitly distinguish itself from the sibling manage_mock.

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

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

It gives useful contextual guidance: mockType defaults and requirements, Electron-only constraints, unsupported Appium/browser mocking, and the advice to use resolved/rejected behaviors for async APIs. However, it never names alternatives like manage_mock or get_mock_calls nor explains when to prefer one over the other.

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 that navigation resets page state including DOM, JS runtime, timers, and frame context. This goes beyond annotations which only provide idempotentHint and destructiveHint.

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. Front-loaded with main action, then additional context. No wasted words.

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

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

For a tool with one parameter and no output schema, the description fully covers purpose, side effects, and usage. Complete and 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?

Schema coverage is 100%, so baseline is 3. Description adds no extra meaning for the url parameter beyond what the schema already describes.

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 loads a URL and waits for page load. It specifies the resource (URL) and action (navigate), differentiating from clicking links.

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: 'Use instead of clicking links when the target URL is known.' This provides clear usage context and 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 only set destructiveHint=false. The description explains the core behavior (installing and opening an extension page) and adds the important nuance about base64 for remote sessions. It does not mention error conditions or side effects, but given the minimal annotations, it provides sufficient transparency beyond the 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?

Two sentences: the first defines the core function, the second adds a critical usage condition. Every sentence earns its place with no redundancy or fluff.

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

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

For a simple tool with 2 required parameters, no output schema, and no nested objects, the description covers the primary behavior, prerequisite, and a key usage scenario. It could briefly mention that after invocation the extension page becomes available for interaction via other tools, but overall it is sufficiently 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 100% coverage, so the schema already documents both parameters. The description adds value by specifying 'Use base64 for cloud/remote sessions', which provides practical context for one of the extensionData options beyond the schema's generic 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 verb ('installs', 'opens') and the resource ('web extension through WebDriver BiDi') and explains the purpose ('so existing MCP tools can inspect and drive its UI'). It is distinct from sibling tools like start_session or navigate which deal with sessions or 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?

The description explicitly states a prerequisite ('Requires a BiDi-enabled browser session') and provides a specific guidance for cloud/remote sessions ('Use base64'). While it does not list when not to use or alternatives, the context is clear and helpful.

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 idempotent and non-destructive behavior. The description adds that the tool waits for the rotation animation to complete, which is a meaningful behavioral detail. The 'no effect in browser sessions' also clarifies its scope beyond the 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?

The description is concise, using two sentences that directly convey the action, behavior, purpose, and constraints. There is no extraneous information, and the structure is easy to parse.

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

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

For a simple tool with no output schema, the description covers all necessary context: what it does, when to use it, its platform restriction, and its blocking behavior. It is sufficiently complete for an agent to invoke correctly.

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

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

The schema provides full coverage for the single 'orientation' parameter, including an enum with values and a description. The tool description reiterates the same values without adding additional semantic detail, so it does not go 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 tool's function: rotating a mobile device to portrait or landscape orientation. It also specifies the resource (mobile device) and the action (rotate), and notes it is for testing orientation-dependent layouts. This distinguishes it from other tools without ambiguity.

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

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

The description gives a specific use case ('Use to test orientation-dependent layouts') and a clear constraint ('Mobile-only; no effect in browser sessions'). While it doesn't explicitly name alternative tools, it provides enough context for an agent to decide when to invoke 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?

The description adds context beyond annotations: it specifies browser-only behavior, direction limitations, and pixel-based scrolling. While it doesn't detail scrolling smoothness or wait behavior, it provides sufficient behavioral context for a simple action.

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. The first sentence delivers the core purpose, the second adds essential constraints. Perfectly 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?

For a simple scroll tool with two parameters and no output schema, the description covers the key aspects: vertical scrolling, pixel amount, direction limits, and platform scope. It lacks mention of relative vs absolute scrolling but is otherwise complete.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds meaning by connecting 'pixel amount' to the pixels parameter and confirming the direction enum. This is a slight but helpful enhancement over the schema alone.

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

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

The description states 'Scrolls the page vertically by a pixel amount,' which is a specific verb+resource+attribute. It also distinguishes from swipe and notes no horizontal support, making the purpose crystal clear.

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

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

The description explicitly says 'Browser-only — for mobile scrolling use swipe,' giving direct when-not-to-use and an alternative. It also clarifies that only up/down scrolling is supported, guiding 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?

Annotations already indicate idempotentHint and destructiveHint, and the description adds useful behavioral context about active-session requirements and cross-domain restrictions. No contradiction 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?

The description is concise: two sentences carry the purpose, constraint, and use case without redundant wording.

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 gives enough context for an agent to decide when to use the tool, including prerequisites and typical use cases. No output schema exists, so no return-value documentation is needed.

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 baseline applies. The description does not add extra parameter-level nuance, but the schema already documents all parameters including defaults and the sameSite enum.

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

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

Description states a specific verb and resource: 'Sets a browser cookie on the active session.' It clearly distinguishes this from sibling tools like set_value, get_cookies, and delete_cookies by focusing on cookie injection.

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

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

Explicit usage guidance is provided: 'Use to inject session tokens or feature flags without login flows.' It also states the key prerequisite and limitation: the browser must already be on the target domain because cookies cannot be set cross-domain.

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 idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable context: it overrides GPS for the session, affects both browser and mobile location services, and requires pre-granted permissions. This goes beyond the annotations without contradicting them.

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 redundancy. The primary action and scope are front-loaded, followed by the prerequisite. Every word earns its place.

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

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

For a simple mutation tool with no output schema, the description covers the action, scope, effect, and a key prerequisite. Nothing an agent needs to invoke it correctly is missing, and the sibling set contains no competing tool for this action.

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 latitude, longitude, and altitude are already documented. The description does not add syntax or format details beyond what the schema provides, but it does clarify the overall scope ('for the session'), which is not parameter-specific. Baseline 3 is appropriate given the schema's completeness.

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

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

The description clearly states the verb 'overrides' and the resource 'GPS coordinates', and specifies the effect on navigator.geolocation and location services. It is unambiguous and distinct from sibling tools like set_value or set_cookie, which operate on different resources.

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 mentions a prerequisite (location permissions must be granted) and implies the use case: overriding geolocation for a session. It does not explicitly state when not to use it, but no sibling tool provides an alternative for geolocation override, so the guidance is adequate.

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 value beyond annotations: clarifies clearing behavior, event triggering, scrolling default. Annotations already indicate idempotent/non-destructive, description enriches 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?

Three concise sentences, each providing distinct, useful information. No redundant or missing elements.

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 main behavioral aspects (clear, type, events, scroll) for a simple action. No return value needed. Minor omission: no mention of timeout 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?

Schema covers all 4 parameters with descriptions. Description adds default for scrollToView and reiterates value replacement, but does not significantly extend 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 the action: clears and types character by character into input/textarea. Distinguishes from sibling tools which are mostly navigation/scripting related.

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 simulating keystrokes with events, but does not explicitly advise when to use this tool versus alternatives like execute_script for direct value setting.

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 carry destructiveHint=false, so the behavioral burden falls on the description. The description adds valuable side-effect information: starting a new session closes or detaches the existing session, and attach: true uses an already-running Chrome via CDP. There is no contradiction with the annotations because the description does not falsely claim a write or delete operation beyond what 'start' implies.

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

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

The description is only three sentences, with the main purpose stated first. The one-session constraint and CDP attach option are focused high-value details. No sentence is wasted, and the length is appropriate for a high-level session-launch tool whose parameter details live in the schema.

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 rich 100%-covered schema, the description and annotations are mostly sufficient for correct invocation. It covers the core lifecycle caveats (single active session, close/detach on new start, CDP attach) and side effects. It lacks explicit sibling routing for launch_chrome/attach_session, but the schema owns the parameter complexity.

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

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

Schema description coverage is 100%, so every one of 39 parameters is already documented in the input schema. The description adds no real semantic detail beyond the schema and does not compensate for any missing parameter context. This matches baseline score 3 for high schema coverage.

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

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

The description clearly states the verb (starts) and specific resources (browser, local Electron application, mobile automation session), which makes the core purpose unambiguous. It also distinguishes attaching via CDP from fresh launches, but it does not explicitly differentiate from sibling tools like launch_chrome or attach_session, so it stops short of a 5.

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

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

The description gives practical guidance: only one active session is allowed, and starting another closes or detaches the existing one, which is important when an agent decides whether to start a session. It also tells the agent when to use attach: true for an existing Chrome over CDP. However, it does not describe when to prefer sibling tools like attach_session or launch_chrome, so it lacks explicit disambiguation.

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?

Beyond the destructiveHint annotation, the description adds useful behavioral context such as full-screen scope, direction semantics, and that no error occurs if content cannot scroll further.

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

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

Three concise sentences with no redundancy; key differentiators and edge-case behavior are included without excess 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?

The description fully equips an agent to invoke the tool correctly, including the mobile-only constraint and alternatives, and no output schema exists to require return-value documentation.

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 descriptions for all parameters, and the description adds valuable clarification that direction refers to content movement, not finger movement.

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 ('Performs a full-screen swipe gesture') and resource, and explicitly distinguishes itself from related tools like scroll and drag_and_drop.

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 when-to-use guidance: 'For browser scrolling use scroll; for dragging a specific element use drag_and_drop' and notes it is mobile-only.

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 indicate idempotent and non-destructive behavior. The description adds persistence detail and parameter flexibility (name or index). 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?

Four sentences, each adding distinct value: purpose, per-context guidance, persistence, parameter details, dependency reference, and scope. 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 one parameter, 100% schema coverage, and no output schema, the description is thorough. Minor gap: no mention of error behavior for invalid context, but generally 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?

Schema coverage is 100% but the description adds meaning: explains the parameter accepts context name or 1-based index, provides examples, and references the wdio resource for index use.

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 ('switches between native and webview automation contexts'), identifies the resource (automation context), and distinguishes from sibling tools like get_contexts and navigate.

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

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

It provides explicit guidance: when to use each context type (accessibility IDs vs CSS/XPath), states that changes persist, and recommends using get_contexts to discover targets. Also notes 'Mobile-only' to limit scope.

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 provide idempotentHint and destructiveHint. The description adds valuable behavioral details: wait of up to 5 seconds for the iframe, browser-only constraint, and persistence of frame context. This goes beyond the annotations and helps the agent understand state implications.

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 that front-load the purpose and essential usage details. Every word serves a purpose, making it efficient and easy to parse.

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

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

For a simple tool with one optional parameter and no output schema, the description comprehensively covers the main use case (switching to iframe and back), persistence behavior, wait time, and environment constraint (browser-only). No gaps are apparent.

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 the parameter description explaining 'selector'. The description reinforces that omitting the selector switches back to top-level, which is already in the schema. It adds no new semantic depth beyond what the schema provides, so a baseline 3 is appropriate.

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

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

The description clearly specifies the tool's function: switching WebDriver frame context into an iframe or back to top-level. It uses a specific verb 'Switches' and resource 'WebDriver frame context', and distinguishes itself from sibling tools like 'switch_context' by specifying browser-only and iframe focus.

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

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

The description provides clear context on when to use the tool: for iframe switching and back to top-level. It explains that changes persist and affect subsequent calls, but does not explicitly state when not to use it or mention alternatives. This is adequate but not exhaustive.

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 idempotentHint=true and destructiveHint=false indicate safety. The description adds that subsequent tool calls affect the active tab, which is key behavioral context. No contradictions; it accurately describes a non-destructive focus action.

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

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

Three sentences, no wasted words. The key action is front-loaded, and each sentence adds distinct value (action, effect, guidance, alternative). Highly efficient.

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

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

For a simple tab-switching operation, the description covers the purpose, input options, effect on subsequent calls, and context boundaries (browser vs. mobile). No output schema is needed; the behavioral impact is well explained.

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 parameter descriptions already provided. The description reinforces mutual exclusivity ('Provide handle OR index') but adds no new semantic details beyond what the schema offers. Baseline 3 applies.

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

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

The description uses the specific verb 'Focuses' and resource 'browser tab', clearly stating the action. It distinguishes from the sibling tool 'switch_context' by noting 'Browser-only; use switch_context for mobile webviews.'

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

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

It instructs to provide handle OR index and references get_tabs to find them. It also notes that subsequent calls operate on the active tab. The alternative switch_context is explicitly mentioned for mobile webviews, though it doesn't list specific when-not-to-use 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?

Even though annotations are minimal, the description discloses important behavioral details: it does not scroll or wait, so the element must already be visible. It also clarifies the native tap mechanism, which is valuable context beyond the destructiveHint annotation.

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, using only three sentences to convey purpose, usage constraints, and platform/behavioral notes. There is no redundancy or unnecessary elaboration.

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

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

Given the simplicity of the operation and the absence of an output schema, the description provides sufficient context: what it does, when to use it, preconditions (element visible), and input alternatives. The agent can confidently decide when to call 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?

All three parameters are described in the schema, and the description adds the critical exclusivity constraint: 'selector OR both x and y'. This extra guidance goes beyond the schema and clarifies how the parameters relate.

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 (taps), the target (matched element or absolute coordinates), and distinguishes it from click_element on iOS, which helps an agent understand its specific use case.

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

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

It explicitly tells when to use it ('Use instead of click_element on iOS where element.click() is ignored'), provides the input constraint ('Provide selector OR both x and y'), and notes the platform restriction ('Mobile-only').

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 destructiveHint annotation is present and the description does not contradict it. However, the description focuses on requirements rather than side effects or consequences, leaving some behavioral aspects implicit. Given the annotation, this is adequate but not highly detailed.

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, using two sentences with no redundant words. It front-loads the primary action and includes necessary constraints without fluff.

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

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

The description includes the parameter, operational prerequisites, and platform-specific notes. It does not mention output (no output schema) or error handling, but for a specific action tool this is sufficiently complete given the context.

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

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

The schema description covers the single 'url' parameter with 'Deeplink URI to trigger through the Electron service,' achieving 100% coverage. The description adds no additional semantics beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Triggers' and the object 'deeplink' through the active Electron application, distinguishing it from generic navigation. It also mentions specific prerequisites (scheme matching, packaged binaries) that further clarify its 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 explicit conditions for use: the Electron session must have a matching scheme and packaged binaries are required on Windows/Linux. It implies when to use this tool (for deeplinks) but does not explicitly indicate alternatives, though the conditions offer practical 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 provide destructiveHint: false. The description adds that it uploads a local file (non-destructive locally) and returns a URL. No additional behavioral details like auth or limits are given, but it does not contradict 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?

One sentence that front-loads the main action and includes essential output info. No wasted words.

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

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

Describes purpose, providers, and return value. Lacks mention of optional parameters (region, customId) but schema covers them. Reasonably complete for a 4-param tool with no 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 covers all 4 parameters with descriptions (100% coverage). The description reiterates file types and providers but does not add new parameter-level insights. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'upload' and the resource 'local .apk or .ipa', lists the cloud providers, and mentions the return value for use in start_session. It effectively distinguishes from sibling tools which deal with sessions, navigation, etc.

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: when needing to upload an app file for later use in start_session. It lacks explicit when-not or alternatives, but the context is clear enough.

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