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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context: it opens a dashboard, waits for user interaction, and returns specific outputs (annotated screenshot, ARIA snapshot, list of annotations). This is additional value 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 a single sentence that is front-loaded with the action and purpose, then lists the return values. Every word serves a purpose, no fluff.

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

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

Despite no output schema, the description fully explains what the tool does and what it returns: annotated screenshot, ARIA snapshot, and list of annotations. It also indicates the interactive nature ('wait for the user'). For a tool with no parameters and simple behavior, this is complete.

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

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

The input schema has zero parameters, so the description cannot add parameter meaning. Per rubric, 0 parameters yields a baseline of 4. The description correctly avoids inventing parameters.

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

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

The description clearly states the verb 'Open the Playwright Dashboard in annotation mode' and the resource 'current page', specifying the action and its scope. It distinguishes itself from sibling tools like browser_take_screenshot or browser_snapshot by focusing on user-drawn annotations and returning annotations, not just a screenshot or snapshot.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. The usage context is implied but not explicitly compared to other browser tools (e.g., browser_highlight, browser_annotate is unique).

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

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

Annotations already mark the tool as destructive (destructiveHint=true) and not read-only (readOnlyHint=false). The description adds no behavioral context beyond this—e.g., no mention that clicks can trigger navigation, open dialogs, or submit forms. The doubleClick parameter is not explained in the description.

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 six words, which is highly concise. However, the extreme brevity sacrifices important information, making it less effective despite lacking fluff.

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

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

Given the lack of an output schema and the tool's potential destructiveness, the description fails to explain how targets are obtained, what double clicking does differently, or how modifier keys affect behavior. With many sibling tools, more context is needed for correct selection.

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

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

Schema coverage is 100%, so the baseline is 3. The description does not provide any additional meaning beyond the schema; it repeats 'click' without detailing parameter usage or relationships (e.g., how 'target' relates to the snapshot).

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

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

The description states 'Perform click on a web page', which clearly identifies the action (click) and target (web page). It distinguishes from coordinate-based clicks (browser_mouse_click_xy) but does not explicitly differentiate from other interaction tools like browser_hover or browser_type.

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

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

No guidance is provided on when to use this tool versus alternatives such as browser_mouse_click_xy, browser_hover, or browser_type. It does not mention prerequisites (e.g., needing a page snapshot), exclusions, or contextual triggers like form submission.

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

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

Annotations already mark destructiveHint=true and readOnlyHint=false. The description 'Close the page' adds no additional behavioral context beyond what annotations provide, such as what happens to unsaved data, dialog handling, or whether the browser process ends.

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

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

The description is extremely concise at three words, with no unnecessary information. It is front-loaded and efficient. However, it may be too terse, leaving room for ambiguity about the scope of closing.

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 (0 params, no output schema) but destructive. The description is insufficiently complete: it does not specify whether it closes the current tab or the entire browser, nor does it address unsaved changes or dialog prompts. Annotations provide destructiveHint, but the description should add more 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?

There are zero parameters and schema coverage is 100% (vacuously). Per rubric, 0 parameters earns a baseline of 4. The description does not need to add parameter information, but it could have elaborated on the scope of the close action.

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 'Close the page' clearly states the verb (close) and resource (page). It distinguishes itself from sibling tools like browser_navigate or browser_tabs, as closing is a distinct action. However, the ambiguity between 'page' and 'browser' (as seen in the annotation title) slightly reduces clarity.

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

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

No guidance is provided on when to use browser_close versus alternatives such as browser_navigate_back or browser_resume. There is no mention of prerequisites, side effects, or when not to use it.

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

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

Annotations already mark the tool as readOnlyHint=true, openWorldHint=true, destructiveHint=false, indicating safe, non-mutating behavior. The description adds minimal behavioral context beyond that: it says 'returns all console messages' but does not clarify what 'all' means (e.g., from current page only? since last navigation?). The parameter descriptions fill some gaps, but the tool description itself adds little transparency.

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

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

The description is a single sentence with no filler or redundancy. Every word is necessary. It is appropriately concise for a straightforward read-only retrieval tool.

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

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

Given the tool's simplicity (3 parameters, no nested objects, no output schema), the description is adequate but incomplete. It does not specify the return format (e.g., array of objects with message, level, timestamp?) or describe side effects like clearing the console after reading. These gaps reduce confidence for an agent making autonomous decisions.

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 is 3. The tool description does not add any parameter details beyond what the schema already provides. The description's mention of 'all console messages' loosely ties to the `all` parameter but does not enhance understanding of `level` hierarchy or `filename` behavior.

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

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

The description clearly states the tool returns console messages, with a specific verb and resource. It distinguishes itself from sibling tools like `browser_network_requests` and `browser_cookie_list` by its unique purpose. However, it could be more precise about filtering behavior (the `level` hierarchy) and scope (current session vs. 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 provides no guidance on when to use this tool versus alternatives (e.g., `browser_evaluate` to inject code that reads console, or `browser_network_requests` for network logs). There is no mention of prerequisites, caveats, or when not to use it. The agent must infer entirely from 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 description adds the scope 'all' beyond the annotation 'Clear cookies' and is consistent with destructiveHint: true. However, it does not disclose additional behavioral traits such as impact on sessions, authentication, or domain scope. With annotations already marking it destructive, the description adds modest 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 a single, direct phrase with zero wasted words. It is front-loaded and efficient, earning a top score for conciseness.

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

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

For a simple destructive action with no parameters or output schema, the description is adequate but could be improved by clarifying the scope of cookies (e.g., current origin vs. all storage). It provides the core function but leaves ambiguity that may affect correct usage.

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

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

The tool has no parameters, and the schema coverage is 100%. Per the baseline rule for 0 parameters, a score of 4 is appropriate. No parameter documentation is needed, and the description correctly omits it.

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

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

The description 'Clear all cookies' uses a specific verb (clear) and resource (cookies), and clearly distinguishes from sibling tools like browser_cookie_list, browser_cookie_get, browser_cookie_set, and browser_cookie_delete, which have different purposes.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., browser_cookie_delete for specific cookies), nor does it mention contexts where clearing all cookies is inappropriate or requires caution. It is a bare statement with no usage direction.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive nature is clear. The description adds no behavioral context beyond what the annotations provide (e.g., what happens if the cookie doesn't exist, side effects, or scope). It is consistent but does not enrich understanding.

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

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

The description is a single sentence, front-loaded with the key action. It is appropriately concise with no wasted words, though it could include a bit more context without losing conciseness.

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

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

For a simple destructive tool with one parameter and no output schema, the description is minimal. It does not clarify return behavior, error handling, or how to differentiate this from browser_cookie_clear. The lack of usage guidelines and behavioral detail makes it incomplete for an agent to use effectively.

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

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

Schema description coverage is 100%—the sole parameter 'name' is described as 'Cookie name to delete'. The description does not add any extra meaning or constraints beyond the schema, so it meets the baseline with no added value.

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

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

The description 'Delete a specific cookie' uses a specific verb and resource, clearly distinguishing this tool from siblings like browser_cookie_clear (deletes all cookies) and browser_cookie_set (creates/updates). It leaves no ambiguity about what the tool does.

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

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

No guidance is provided on when to use this tool versus alternatives such as browser_cookie_clear or browser_cookie_set. There are no preconditions, error scenarios, or contextual hints that help an agent decide between 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 declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context such as what happens if the cookie is not found, the source page context, or return format.

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?

A single, concise sentence that front-loads the purpose. 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 simple 1-parameter tool with no output schema, the description is technically adequate but lacks detail on return value structure (e.g., cookie object fields). It does not fully compensate for the missing output schema specification.

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 a clear description for the 'name' parameter. The description adds no extra meaning beyond the schema; a 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 'Get a specific cookie by name' uses a specific verb and resource, clearly distinguishing it from siblings like browser_cookie_list (all cookies) and browser_cookie_set (set a cookie).

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

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

No guidance on when to use this tool versus alternatives. For example, it does not mention that browser_cookie_list should be used when multiple cookies are needed, or that browser_cookie_set is for modifications.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds that it lists all cookies optionally filtered, but does not disclose any additional behavioral traits (e.g., performance impact, pagination, or data freshness). With annotations covering the core safety profile, the description offers minimal extra 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 a single sentence that is perfectly front-loaded with the main action ('List all cookies') and conditional filtering. Every word earns its place; there is zero redundancy 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?

Given the absence of an output schema, the description fails to explain what the tool returns (e.g., list of cookie objects, details included). With only 2 optional parameters and no mention of return format or pagination, the description is incomplete for an agent to fully understand the context of the response.

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%—both parameters (domain and path) have descriptions in the schema. The description merely restates that filtering is optional, adding no new meaning beyond what the schema already provides. Baseline 3 is appropriate 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 'List all cookies' with optional filtering by domain/path, providing a clear verb+resource combination. It distinguishes this tool from siblings like 'browser_cookie_get' (single cookie retrieval) and 'browser_cookie_delete' (deletion) by specifying the listing action and optional filters.

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 listing cookies but does not provide explicit guidance on when to use this tool versus alternatives like 'browser_cookie_get' or 'browser_cookie_delete'. No exclusions or contextual cues are given, leaving the agent to infer based on tool names alone.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, making the modifying nature of this tool clear. The description adds the list of optional flags (domain, path, expires, httpOnly, secure, sameSite), which provides some extra behavioral context beyond the annotations. However, it does not describe key behaviors such as whether existing cookies are overwritten, how the domain defaults, or error conditions, keeping transparency adequate but not rich.

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 of 12 words that conveys the core action and lists the most important optional flags. It avoids redundancy and fluff, making it quick to parse. However, it could be slightly expanded with a usage hint or sibling differentiation without harming conciseness.

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

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

Given the tool's complexity (8 parameters, destructive action) and the presence of complete schema descriptions and annotations, the description provides a reasonable overview. However, it does not explicitly state that setting a cookie modifies the browser's current cookie store, how expiration timestamps work, or the default behavior when domain/path are omitted. These gaps mean the description is only moderately complete for an agent to fully understand the tool's operation.

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

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

Schema description coverage is 100%, so each of the 8 parameters already has a clear description. The description's mention of 'optional flags' and listing a subset of parameters does not add significant meaning beyond what the schema provides. The description adds no new constraints, defaults, or usage relationships, so it meets the baseline but does not enhance semantic understanding.

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

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

The description 'Set a cookie with optional flags' clearly states the verb (set) and resource (cookie), making the tool's purpose unambiguous. Although it does not explicitly contrast with sibling tools like browser_cookie_delete or browser_cookie_clear, the name and action are distinct enough for an AI agent to understand its role among cookie manipulation tools.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., when to set vs. delete or list cookies). It does not mention prerequisites, typical use cases, or what happens when a cookie with the same name already exists. This lack of context forces the agent to rely solely on heuristics or incomplete reasoning about tool selection.

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

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

The description is consistent with annotations (destructiveHint=true, readOnlyHint=false) as it implies a mutation action. However, it adds no behavioral details beyond the annotation hints, such as whether the drag is a continuous mouse gesture or a single-step action, or what events are triggered. With annotations already present, the description holds minimal added 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 a single short sentence that is front-loaded and to the point. It is concise but could include a bit more context without becoming verbose. The brevity does not hinder clarity, but it leaves gaps in completeness.

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

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

Given the tool has 4 parameters, no output schema, and a destructive hint, the description is too minimal. It does not explain what happens after the drag (e.g., if any return value is expected), error conditions, or prerequisites like element visibility. The description is insufficient for an agent to fully understand the tool's behavior without additional structured 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?

All parameters have descriptions in the schema (100% coverage), so the description does not need to compensate. The description mentions 'two elements' which aligns with startTarget and endTarget, but it does not provide additional meaning beyond what the schema already states. Baseline 3 is appropriate.

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

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

Description states 'Perform drag and drop between two elements' which clearly identifies the action (drag-and-drop) and the resource (elements). It is specific enough to distinguish from coordinate-based drag tools like browser_mouse_drag_xy, but does not explicitly differentiate from the sibling browser_drop, which may be a related but distinct operation.

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

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

No guidance is provided on when to use this tool versus alternatives such as browser_mouse_drag_xy (for coordinate-based drag) or browser_drop (for drop events). The description lacks any mention of prerequisites, context, or when not to use it.

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

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

Annotations already provide readOnlyHint=false, destructiveHint=true, openWorldHint=true. The description adds 'as if dragged from outside the page', which clarifies the behavioral context. However, it does not disclose side effects like triggered events or potential navigation, which would be useful for a destructive, open-world tool.

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

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

Two sentences, front-loaded with the action, no redundant words. The critical constraint is included. Every sentence earns its place.

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

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

Given 4 parameters (one required, nested object), no output schema, and sibling complexity, the description is adequate but could be more complete. It does not explain what the tool returns (no output schema) or mention preconditions like element interactability. The permission aspect hinted by the 'element' parameter is not covered.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by stating 'At least one of paths or data must be provided', a constraint not in the schema's required list (only target is required). It also reinforces 'MIME-typed data' for the data parameter. This extra guidance justifies a 4.

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

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

The description clearly states the action: 'Drop files or MIME-typed data onto an element', with a specific verb and resource. It distinguishes from sibling tools like 'browser_drag' (internal drag) and 'browser_file_upload' by noting 'as if dragged from outside the page'. The constraint 'at least one of paths or data' is also mentioned.

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 simulating external drops (vs internal drag-and-drop) but does not explicitly compare to siblings like 'browser_drag' or 'browser_file_upload'. It provides a constraint (at least one of paths/data) but lacks when-not-to-use or alternative recommendations.

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 mark destructiveHint=true and openWorldHint=true, indicating potential side effects and broad impact, but the description does not elaborate on these behaviors. It fails to warn that executing arbitrary JavaScript may modify page state, trigger network requests, or cause other unintended consequences. The description adds minimal transparency 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 a single sentence, concise and front-loaded. It contains no unnecessary words. However, its brevity sacrifices critical information, resulting in under-specification. Still, it is well-structured for its length.

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

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

Given the tool's complexity (JavaScript execution, destructive potential, multiple sibling tools), the description is severely incomplete. It does not explain the difference from browser_run_code_unsafe, the role of element vs target, how permissions work, what the return value looks like, or the implications of the destructiveHint and openWorldHint annotations. The minimal description leaves the agent underinformed.

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 input schema already documents each parameter adequately. The tool description does not add any extra meaning, such as explaining the relationship between 'target' and 'element' or when to use 'filename'. With baseline coverage, a score of 3 is appropriate as the description neither harms nor significantly helps.

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 evaluates JavaScript expressions on a page or element, specifying the verb 'evaluate' and the resource 'JavaScript expression'. However, it does not differentiate from the sibling tool 'browser_run_code_unsafe', which also likely runs JavaScript, leaving ambiguity about when to use each.

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

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

The description provides no guidance on when to use this tool versus alternatives like browser_run_code_unsafe, nor does it mention preconditions, permissions, or when not to use it. The agent is left without context for selection.

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

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

The description adds no behavioral insight beyond the annotations (destructiveHint=true, readOnlyHint=false). It does not disclose that uploading involves interacting with the browser's file dialog, that it may trigger network requests, or that files are sent to the current page. Since annotations already exist, the description should provide additional behavioral context, but it does not.

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 with one short sentence containing no filler. However, it lacks any structure such as bullet points or separation of concerns. For its brevity, it earns high marks but could be slightly more organized if expanded.

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

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

Given the tool's destructive nature (destructiveHint=true) and the presence of many sibling tools, the description is too minimal. It does not explain the typical use case (filling file upload fields in a browser), necessary page conditions, or that the paths parameter can cancel the dialog. The annotations and schema fill some gaps, but the description itself is insufficient for complete context.

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

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

Schema coverage is 100% and the schema description for 'paths' is thorough, so the tool description's restatement adds minimal value. Baseline 3 is appropriate; the description does not harm but does not enhance parameter understanding 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?

The description 'Upload one or multiple files' clearly specifies the verb (upload) and resource (files), but omits the context of uploading to a browser page's file input element. It distinguishes from sibling tools like browser_drop which handles file drop, though not explicitly. Overall specific but could be more precise about the target.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., browser_drop), or on prerequisites such as being on a page with a file input. The description does not clarify that the paths parameter expects absolute local paths, nor does it mention that omitting paths cancels the upload. This leaves the agent without clear usage context.

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

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

Annotations already indicate destructiveHint=true, readOnlyHint=false, openWorldHint=true, meaning it is a mutating operation. The description adds no behavioral context beyond that, such as whether it clears existing fields, requires element visibility, or scrolls. With annotations present, the description should still provide extra behavioral details but fails to do so.

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 (3 words, 1 sentence). While it is front-loaded, it is too brief to be fully informative. It earns its place by stating the core purpose, but it lacks the detail expected for a tool with a complex input schema. Not wasteful, but under-specified.

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

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

Given the tool's complexity (array of objects with 5 fields, each with types and enums), the description is far too minimal. It does not explain how to prepare the form (e.g., obtain a snapshot), what happens if the fields are not found, or what the tool returns. There is no output schema, so the description should compensate. It does not.

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%; each parameter (target, name, type, value) has a clear description in the schema. The tool description 'Fill multiple form fields' does not add any meaning beyond what the schema already provides. The baseline is 3 for high coverage, and the description does not improve or degrade parameter understanding.

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

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

The description 'Fill multiple form fields' clearly states the action (fill) and the resource (form fields). The name 'browser_fill_form' and the input schema (array of fields) reinforce that it handles multiple fields at once. It distinguishes from siblings like 'browser_type' (single field typing) and 'browser_select_option', though it does not explicitly call out alternatives.

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

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

The description provides no guidance on when to use this tool vs alternatives (e.g., browser_type, browser_select_option), no prerequisites (e.g., page snapshot required), and no when-not-to-use conditions. It is a single sentence with no usage context.

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

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

Beyond annotations (read-only, open world), the description details the output format: 'matching snapshot nodes with a few lines of surrounding context (like search snippets), each shown under its path from the root.' This clarifies what the agent receives and that it's cheaper than a full snapshot. 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?

Two sentences: first states purpose, second describes output and benefit. No redundant words, information is front-loaded and efficiently communicated.

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 missing output schema, the description sufficiently describes return format and performance characteristic. Parameters are fully documented in schema. Annotations cover safety. The tool is simple and the description is complete for an agent to understand usage and outcome.

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 both parameters with detailed descriptions (text: case-insensitive substring; regex: flags via slashes). The description does not add new parameter meaning beyond schema. With 100% schema coverage, 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 searches the accessibility snapshot for text or regex, and distinguishes it from browser_snapshot by emphasizing it's cheaper for locating elements. The verb 'search' and resource 'accessibility snapshot' are specific and 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?

Description implies when to use (locating an element and its ref cheaply) and contrasts with capturing full snapshot. However, it does not explicitly state when to choose text vs regex, nor name sibling alternatives like browser_snapshot directly. Still provides good 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?

Annotations declare destructiveHint=true and readOnlyHint=false, indicating the tool mutates state. However, the description adds no behavioral context beyond these annotations. It does not disclose that accepting a dialog may close it, that dismissing requires setting accept=false, or that promptText is only applicable for prompt dialogs. The description carries no added 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 a single sentence, but it is too concise to be useful. It is a tautology that does not front-load actionable information. Every word should earn its place; here, the description fails to inform the agent about what the tool does or how to use it.

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

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

Given the tool's complexity (handling browser dialogs) and the absence of an output schema, the description is incomplete. It does not explain the return value, the typical sequence (e.g., dialog must be present), or the relationship with other tools like browser_click or browser_navigate. The annotations provide some hints, but the description should carry more of the burden.

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

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

The input schema has 100% description coverage, with clear descriptions for both parameters. The description 'Handle a dialog' adds no additional meaning about the parameters. It does not clarify that 'accept' is required, or that 'promptText' is only relevant for prompt dialogs, which would help an agent understand parameter usage 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 'Handle a dialog' is a tautology of the tool name 'browser_handle_dialog'. It restates the name without specifying what kind of dialog (e.g., alert, confirm, prompt) or what actions are involved (accept, dismiss, provide text). This fails to distinguish the tool from the many sibling browser tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this tool is typically used after a dialog appears, nor does it explain that it is needed to proceed with further browser interactions. No exclusions or alternatives are given.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds minimal behavioral context beyond stating the action. For a simple tool, this is acceptable but does not enrich the agent's understanding of side effects or prerequisites.

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

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

The description is a single, short sentence containing exactly the necessary information. Every word earns its place, with no redundancy or fluff. It is efficiently front-loaded.

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

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

For a simple tool with fully described parameters, the description is adequate but lacks explicit mention of prerequisites (e.g., that a highlight must have been previously added via browser_highlight) and does not specify the effect on the page or reversibility. Given the tool's simplicity, it is acceptable but not fully 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% and the schema itself provides detailed descriptions for both parameters ('target' and 'element'). The tool description adds no additional meaning or context about the parameters, so it meets the baseline with no extra value.

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

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

The description clearly states the verb 'Remove' and the resource 'highlight overlay', and it is specific about the action being the inverse of adding a highlight. Among siblings, browser_highlight exists, so the distinction is clear without needing explicit mention.

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 should be used to undo a previously added highlight, but there is no explicit guidance on when to use it versus alternatives like browser_annotate or browser_hover. No exclusions or context are provided, so usage guidance is only implied.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, confirming no destructive side effects. The description adds that the highlight is 'persistent' and an 'overlay', which are useful behavioral details beyond annotations. No contradictions.

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

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

The description is a single, concise sentence that clearly states the action and effect. It is appropriately front-loaded and contains no superfluous information.

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

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

Given the simple nature of the tool and good schema coverage, the description is nearly adequate. However, it does not mention that the highlight is visual-only and non-interactive, which could be helpful for an AI agent to understand the tool's scope. No output schema is provided, but the tool likely has no meaningful return value.

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

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

Schema coverage is 100%, so the description does not need to add much. It does not explain parameter semantics beyond what the schema already provides (e.g., 'style' for additional CSS, 'target' for reference, 'element' for permission). 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 action ('show a persistent highlight overlay') and the target ('element on the page'). It distinguishes from sibling tools like browser_hide_highlight or browser_hover, though it could be more explicit about the persistence aspect differentiating it.

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

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

The description implies the tool is for visually highlighting an element, but it does not specify when to use it versus alternatives (e.g., browser_hover for temporary attention, browser_hide_highlight for removal). No usage context or exclusions are provided.

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

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

The annotations indicate readOnlyHint=false and destructiveHint=true, meaning the tool may cause side effects. However, the description simply says 'Hover over element' without explaining potential behavioral impacts (e.g., triggering hover events, loading resources, or changing page state). It adds no context beyond what the annotations already state, and fails to clarify why the tool is classified as destructive.

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 five-word sentence, which is very concise and front-loaded. However, it is so minimal that it sacrifices crucial information about usage and behavior. While not verbose, it under-specifies for a tool with non-trivial annotations.

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 openWorldHint=true and destructiveHint=true annotations, the agent needs to understand the tool's side effects and appropriate usage. The description provides almost none of this context. It does not mention what happens after hover (e.g., whether it returns results, waits for effects, or requires interaction permission). The lack of an output schema further increases the need for descriptive context, which is absent.

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 both parameters have detailed descriptions in the input schema. The tool description adds no additional meaning or usage context for the parameters. Baseline 3 is appropriate as the schema already does the heavy lifting.

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 'Hover over element on page' uses a clear verb+resource pattern, unambiguously stating the tool's action. However, among many sibling interaction tools (e.g., browser_click, browser_mouse_move_xy), it does not differentiate what 'hover' entails versus moving the mouse or clicking. The purpose is clear but lacks sibling distinction.

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

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

No usage guidance is provided. The description does not indicate when to prefer hover over alternatives like click, mouse_move_xy, or drag. There is no mention of prerequisites (e.g., element visibility, scroll-into-view) or when not to use this tool. The agent receives no help in tool selection.

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

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

The description adds no behavioral context beyond what the annotations already provide (destructiveHint=true, readOnlyHint=false). It merely restates the tool name, offering no insight into side effects, scope (e.g., current origin), or reversibility.

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

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

The description is a single, front-loaded sentence with no wasted words. It is optimally concise for the tool's simplicity.

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

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

Given the tool has no parameters, no output schema, and annotations provide destructive hint, the description is minimally adequate. However, it lacks explicit scope (e.g., current origin) and does not mention that it clears all keys, which could be inferred but is not stated.

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

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

There are zero parameters, and the schema coverage is trivially 100%. Per rules, baseline is 4; the description does not need to add parameter meaning.

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

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

The description 'Clear all localStorage' uses a specific verb ('Clear') and resource ('all localStorage'), clearly distinguishing it from sibling tools like browser_localstorage_delete (specific key) and browser_sessionstorage_clear (different storage).

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., browser_localstorage_delete for selective removal) or any caution about its destructive nature, despite the destructiveHint annotation.

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 explicitly states the action is destructive (via annotations destructiveHint: true), and the title repeats the purpose. However, the description itself does not add behavioral context beyond what annotations provide, such as whether the action triggers side effects (e.g., page reload), is reversible, or requires certain permissions. With annotations already covering the destructive nature, the description meets the baseline but adds no extra transparency.

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

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

The description is a single, concise sentence that is front-loaded and directly states the action. It wastes no words and is efficiently structured. It earns a high score for brevity, though it could be slightly expanded without becoming verbose (e.g., clarifying scope).

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

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

Given the tool's simplicity (1 param, no output schema), the description is minimally sufficient for a basic delete operation. However, it lacks context about what happens if the key does not exist (e.g., error or no-op), whether the action affects other storage types, and the browser state prerequisites (e.g., a page must be loaded). For a destructive action, these gaps reduce 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?

The input schema has 1 parameter (key) with 100% description coverage—the schema already describes 'key' as 'Key to delete'. The description does not add additional context about the parameter (e.g., format, length limits, case sensitivity). Since schema coverage is complete, a baseline score of 3 is appropriate; the description provides no extra value for parameter understanding.

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

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

The description 'Delete a localStorage item' clearly states the verb ('Delete') and resource ('localStorage item'), which aligns with the tool's name. However, it does not differentiate itself from sibling tools like 'browser_localstorage_clear' (which deletes all items) or 'browser_cookie_delete' (which deletes cookies but could be confused if the agent conflates storage types). A minimal distinction is implied by the resource name, 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?

No guidance is given about when to use this tool versus alternatives. For example, there is no mention that this tool deletes a single item by key, whereas 'browser_localstorage_clear' deletes all items. There is also no context about prerequisites (e.g., needing to navigate to a page first) or when not to use it (e.g., if you need to delete session storage, use session storage tools). The agent must infer usage from the tool name and input schema alone.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds no behavioral context beyond that, such as what happens if the key doesn't exist or any other runtime behavior. It does not contradict annotations, but also does not add 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 a single, well-formed sentence that conveys the core purpose without any superfluous words. It is optimally concise for a simple getter tool.

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

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

For a tool with no output schema and a single required parameter, the description fails to explain the return value (e.g., what is returned if the key is missing) or any behavior quirks. Given the simplicity, it could still be more informative about edge cases.

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

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

Schema description coverage is 100% with the schema already describing the 'key' parameter as 'Key to get'. The tool description merely says 'by key', which adds no new meaning. A baseline of 3 would be appropriate if the description added value, but here it is redundant.

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 'Get' and the resource 'localStorage item' with the method 'by key'. It unambiguously identifies the tool's function and distinguishes it from sibling tools like set, delete, and list.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., browser_localstorage_list for all keys) or any context about prerequisites or side effects. It is a single sentence with zero usage directives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds minimal behavioral info beyond confirming it lists all pairs. However, for a simple read-only tool, the description is sufficient; no further behavioral detail (e.g., potential size limits, encoding) is necessary given the annotations. No contradiction detected.

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

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

The description is a single, clear sentence that conveys the full purpose without any wasted words. It is front-loaded and efficient, earning its place perfectly.

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 parameterless, read-only tool with no output schema, the description is close to complete. It could optionally mention the return format (e.g., 'returns a list of key-value pairs'), but the absence is minor given the tool's simplicity and the existing annotations.

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

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

Schema coverage is 100% with zero parameters, so the baseline is 4 per guidance. The description adds no parameter details (none needed) but effectively communicates the tool's scope (all pairs), which aligns with the empty schema.

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

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

The description 'List all localStorage key-value pairs' clearly states the specific verb (list), resource (localStorage key-value pairs), and scope (all). It distinguishes itself from siblings like browser_localstorage_get (which retrieves a specific key) and browser_localstorage_clear (which deletes all entries), though it doesn't explicitly call out these differences.

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 listing all localStorage entries but provides no explicit guidance on when to use this tool vs alternatives like browser_localstorage_get for specific keys or browser_storage_state for a full storage snapshot. No context on prerequisites or temporal conditions (e.g., page must be loaded) is given.

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

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

Annotations declare destructiveHint=true and readOnlyHint=false, clearly indicating this operation modifies persisted browser state. The description, however, does not elaborate on any behavioral traits beyond 'Set'. It fails to mention that existing values are overwritten, that the operation only affects the current origin, or that there is no return/output schema defined. It provides no 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?

The description is a single concise sentence, containing exactly one verb and one object. It is front-loaded with the action. Every word is necessary. No redundancy 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?

Given no output schema, the description should mention what the tool returns or confirms (e.g., no return value). It also lacks any note about persistence scope (origin, page), error conditions (e.g., quota exceeded, blocked due to settings), or side effects (trigger of storage events). For a simple mutation tool with destructive hint, completeness is lacking.

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

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

Schema description coverage is 100%, so the schema already documents 'key: Key to set' and 'value: Value to set'. The description does not add any meaning beyond those names—no constraints (e.g., max length, allowable characters, JSON serialization hint), no relationship between key and value (e.g., value may be stringified), and no defaults. Baseline 3 is not warranted because the description adds zero parameter insight.

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 'Set a localStorage item' uses a specific verb ('Set'), a concrete resource ('localStorage item'), and the name clearly mirrors this. It is distinct from siblings like browser_localstorage_get, browser_localstorage_delete, and browser_localstorage_clear. The only minor lack is not explicitly stating that it operates on the browser page's localStorage, but the sibling context and title make that clear.

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

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

The description provides no guidance on when or when not to use this tool versus alternatives. For example, it does not mention that localStorage.persists across navigations (unlike sessionStorage) or that sensitive data has security/clearance implications. Given numerous related storage tools in siblings (browser_localstorage_list, delete, clear, sessionstorage_set, etc.), the lack of selection cues is a gap.

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 destructiveHint=true and readOnlyHint=false, so the agent knows this is a mutation. However, the description adds no behavioral context beyond the schema: it doesn't explain coordinate system (viewport vs page), whether the click triggers JavaScript events, or what happens if coordinates are out of bounds. With annotations present, the description still falls short of providing useful behavioral depth.

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

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

The description is a single, clear sentence with no extraneous words. Every word is meaningful and immediately conveys the tool's core action.

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

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

Given the tool's simplicity, 5 parameters fully covered in schema, and useful annotations, the description is minimally adequate. However, it lacks orientation (e.g., coordinate system), does not mention the default button or the effect of delay/clickCount, and provides no output expectations. A 3 reflects that edge-case context is missing.

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

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

Schema description coverage is 100%, so all 5 parameters are documented in the input schema. The description ('at a given position') aligns with the required parameters x and y but does not add new meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Click') and resource ('mouse button') with a clear location ('at a given position'), effectively differentiating from sibling tools like 'browser_click' (which clicks on an element) and 'browser_mouse_move_xy' (only moves).

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., browser_click, browser_mouse_down). It lacks instructions on when a raw coordinate click is appropriate or what prerequisites (e.g., page loaded, element at coordinates) exist. Sibling tools with overlapping functionality are not 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?

Annotations already indicate destructiveHint=true and readOnlyHint=false, signaling a state-changing action. The description adds no extra behavioral context beyond what the annotations provide, such as that the button remains pressed until a mouse_up event.

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

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

The description is extremely concise at three words, leaving no unnecessary text. It is direct and front-loaded, efficiently conveying the core action.

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

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

Given the simplicity of the tool (one optional param, no output schema), the description is too minimal. It fails to explain that the mouse button is held down until a complementary action (like mouse_up), and it does not relate to the coordinate-based siblings. This leaves the agent without crucial context for proper use.

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

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

Schema coverage is 100% with a well-described enum parameter for button. The description does not mention the parameter, but the schema already handles it. Baseline 3 is appropriate since the description adds no additional 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 'Press mouse down' clearly identifies the action as a mouse press event. It is specific enough to distinguish from sibling tools like browser_mouse_up or browser_click, but it does not explicitly state that it is a press without release, which could be ambiguous.

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

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

There is no guidance on when to use this tool versus alternatives like browser_mouse_click_xy or browser_drag. No context is provided about typical usage patterns (e.g., pairing with mouse_up) or when to prefer this over a higher-level click.

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 destructiveHint=true and readOnlyHint=false, indicating the tool performs a mutation. The description adds negligible behavioral context beyond the name, simply restating that it drags the left mouse button. It does not disclose that the action simulates a drag sequence (mousedown, mousemove, mouseup) or that it may trigger events or change page state.

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

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

The description is a single sentence of six words, extremely concise and front-loaded. Every word carries meaning. However, it is so brief that it sacrifices some clarity (e.g., missing the start position).

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

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

Given the tool has 4 required parameters, a destructive annotation, and many sibling tools with similar functionality, the description is too sparse. It does not explain the drag behavior, coordinate system, or how it differs from 'browser_drag' or manual mouse actions. No output schema exists, so the description should provide more context about return values or side effects.

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

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

Schema description coverage is 100%, with each parameter having a basic description (e.g., 'Start X coordinate'). The description adds no additional parameter semantics, so the baseline of 3 is appropriate. The description does not explain coordinate system (e.g., viewport vs page) or required units.

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 ('Drag left mouse button') and the target ('to a given position'), which identifies the tool's purpose. However, it does not explicitly mention the start position, which is required by the schema, and does not differentiate from sibling tools like 'browser_drag' or 'browser_mouse_move_xy'.

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'browser_drag', 'browser_mouse_click_xy', or 'browser_mouse_down'+'browser_mouse_up'. No explicit context, prerequisites, or exclusion criteria are given.

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

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

Annotations indicate destructiveHint=true and readOnlyHint=false, suggesting the move could trigger side effects (e.g., hover events, CSS changes), but the description does not explain what happens upon moving the mouse (events triggered, visual feedback, error conditions). It adds no behavioral context 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 one short sentence with no unnecessary words. It is concise, though it sacrifices some completeness. It earns a high score for being front-loaded and efficient.

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

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

Given the lack of output schema and the presence of many sibling mouse tools, the description is incomplete. It does not specify whether the move is absolute or relative, whether it triggers mouse events, or what happens if coordinates are out of bounds. Additional context would help an agent use this tool correctly.

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

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

Schema description coverage is 100% (both x and y have 'X coordinate' and 'Y coordinate' descriptions), so the baseline is 3. The tool description adds no extra parameter context such as coordinate system (viewport vs page), units (pixels), or valid ranges, but it does not need to compensate since the schema is sufficient.

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 'Move mouse to a given position' clearly states the action (move) and resource (mouse position), with a specific verb. Among sibling tools like browser_mouse_click_xy and browser_mouse_drag_xy, this tool uniquely focuses on moving without clicking or dragging.

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

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

No guidance is provided on when to use this tool vs alternatives such as browser_hover, browser_mouse_click_xy, or browser_drag. The description does not clarify scenarios where a plain move is preferred (e.g., to position the cursor before a separate click) vs other mouse actions.

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?

描述没有添加注释中已经提供的破坏性提示之外的任何行为背景。没有说明操作的副作用或先决条件。

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?

描述仅三个词，过于简短，以牺牲目的清晰度为代价追求简洁。

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?

考虑到大量兄弟工具和缺乏输出模式，描述完全没有说明'mouse up'的含义，与其他鼠标操作的关系，或任何使用条件，非常不完整。

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?

模式描述覆盖率为100%，模式中已有按钮参数的描述，描述没有添加新信息，符合基线3。

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?

描述'Press mouse up'基本上是工具名称的同义反复，没有说明'up'是释放按钮还是向上移动。与browser_mouse_down等兄弟工具缺乏区分。

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?

没有提供何时使用此工具或何时使用替代工具（如browser_mouse_down或browser_mouse_click_xy）的指导。

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

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

Annotations declare destructiveHint=true and readOnlyHint=false, which imply the tool can change state (scrolling can trigger events or navigate). The description does not disclose any behaviors beyond the bare action, such as whether it triggers scroll events, affects infinite scrolling pages, or requires a specific target. It adds no value over 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 one short sentence, which is concise, but it omits critical guidance. It is not front-loaded with distinguishing or clarifying information—it simply echoes the name. The lack of substance makes it under-specified rather than efficiently concise.

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

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

Given the tool has 2 required parameters with no output schema, the description should clarify the effect and usage. It fails to explain how deltaX and deltaY relate to on-screen scrolling (e.g., negative Y scrolls up?), or what the tool returns. The sibling tools list includes similar scrolling/mouse tools, adding urgency for better differentiation.

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

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

Schema coverage is 100% with descriptions 'X delta' and 'Y delta' for the two required parameters. The description adds nothing beyond the schema—no clarification of units (pixels? lines?), direction (positive/negative), or typical ranges. Baseline 3 is appropriate since the schema already provides minimal documentation.

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

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

The description 'Scroll mouse wheel' is a near-tautology of the tool's name 'browser_mouse_wheel', restating the action without adding specificity about what kind of scrolling (e.g., smooth, step-based, on-screen element) or the coordinate context. It provides minimal differentiation from siblings like 'browser_mouse_move_xy' or 'human_scroll'.

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 offers no guidance on when to use this tool versus alternatives (e.g., using 'browser_press_key' for page-down, 'human_scroll' for human-like scrolling, or scroll via click/drag). No context is given about prerequisites (e.g., needing a focus element) or use cases.

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

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

The annotations include destructiveHint=true, implying navigation can alter state (e.g., leaving a page, losing unsaved data), but the description contradicts this by not mentioning any destructive behavior. It also omits details like whether the URL must be fully qualified, if the navigation is instant or waits for load, or what happens on error. Without annotations covering these, the description is insufficient.

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

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

The description is a single sentence with no waste. It earns its place, though it could be slightly more informative without being verbose.

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

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

Given the complexity of browser navigation (destructive hint, open world hint), the description is too minimal. It does not cover return values, side effects, or the fact that the page may change state. No output schema exists, so the description should compensate.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter. The description adds no extra meaning beyond what 'url' and its schema description provide.

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 verb and resource ('Navigate to a URL'), which is clear. However, it does not differentiate from sibling tools like 'browser_navigate_back', making it merely adequate.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., browser_click for links, browser_fill_form for forms). The description lacks any context about prerequisites or typical use cases.

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

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

Annotations already mark this as destructiveHint=true (history is lost), which is appropriate. Description adds 'Go back' context. However, it doesn't clarify if this closes modals or dialogs opened by the page, or what happens to page state. Not penalty for lack of explicit behavioral details given annotations already cover the key behavioral aspect.

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

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

Single, clear sentence with no extraneous text. 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 clear annotations and a simple navigation purpose, this is largely complete. However, could mention that it only works when there's a history entry (e.g., after a navigation) to avoid no-op calls. Out of 64 sibling tools, this is sufficiently distinct.

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

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

No parameters are defined, so description doesn't need to add parameter meaning. Schema coverage is 100% (naturally, with zero params). Baseline 4 for no params, but this is a perfect fit—description tells the agent all it needs.

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 verb 'Go back' and resource 'previous page in the history'. It distinguishes from siblings like browser_navigate (which goes to a new URL) and browser_resume (which continues execution). Slight deduction for not specifying whether this only applies to the current tab or all tabs.

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

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

No explicit guidance on when to use this vs alternatives. From context, it's implied for navigation history, but no mention of when not to use (e.g., if browser has no history, or if a fresh navigation should be used instead).

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context: the tool returns headers and body, can return a single part, and is non-modifying. No contradictions.

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

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

Two precise sentences with no filler. First sentence defines the main function and optional behavior, second gives critical usage instruction. 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 retrieval tool with full schema coverage and safety annotations, the description covers all key aspects: what is returned (full details or part), how to identify the request (index from sibling tool), and the optional filename for saving. Missing output schema is mitigated by mentioning the return contents.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by explaining that the index comes from `browser_network_requests` and that `part` restricts output. This goes beyond the schema's static definitions.

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

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

Description clearly states 'Returns full details... of a single network request' with a specific verb and resource. It distinguishes from sibling `browser_network_requests` by referencing the number from that tool, making the purpose unambiguous.

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

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

Explicitly tells the user to 'Use the number from browser_network_requests', establishing a clear usage sequence. Does not provide when-not-to-use or alternatives, but the prerequisite is clear enough for proper invocation.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the temporal scope ('since loading the page') and the format ('numbered list'). It does not disclose behaviors like whether requests accumulate between calls, if pending requests are included, or any pagination. This is adequate but minimal given the annotation safety.

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 precisely states the tool's function and scope, the second provides a direct pointer to the complementary sibling tool. Every word is necessary, no fluff. Highly concise 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?

With no output schema, the description minimally specifies the return format ('numbered list') and mentions the sibling for details. It does not clarify whether the list includes all requests or respects the filter parameter's scope, nor does it address edge cases like empty results or multiple page loads. Acceptable for a simple list tool, but gaps remain.

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 full descriptions for all three parameters (filter, static, filename), so schema coverage is 100%. The description itself does not add any additional meaning or usage guidance for the parameters, meeting the baseline expectation of 3.

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 returns a numbered list of network requests since page load, and explicitly differentiates itself from the sibling tool browser_network_request by directing the agent to use that tool for full details. The verb 'returns' and resource 'network requests' are specific and distinct from other browser tools.

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

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

The description explicitly tells when to use this tool (to get a list of network requests) and points to the sibling browser_network_request for detailed inspection. However, it does not provide explicit guidance on when not to use it or contrast with other network-related siblings like browser_route or browser_network_state_set, leaving some ambiguity for complex 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?

Annotations already indicate destructiveHint=true, so the agent knows it's a destructive operation. The description adds value by explaining the behavioral consequence: 'When offline, all network requests will fail.' This contextualizes the side effect beyond the annotations alone, though it does not cover all potential impacts (e.g., existing connections).

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 states the primary action, the second adds a key behavioral consequence. There is no fluff, and the critical information is front-loaded. Every sentence 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 tool with one parameter, annotations present, and no output schema, the description is sufficient. It covers what it does and a major effect. It omits details like persistence across tabs or return value, but these are not critical given the tool's simplicity and the absence of an output schema.

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

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

Schema coverage is 100% and the schema already describes the 'state' parameter's enum values and their meanings. The description ('Sets the browser network state to online or offline') essentially restates the schema's purpose without adding new semantic detail. Baseline 3 applies.

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

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

The description clearly states the action ('Sets the browser network state to online or offline') and a key consequence ('When offline, all network requests will fail'). It is a specific verb+resource pair that distinguishes itself from sibling tools like browser_network_requests (listing) or browser_route (intercepting).

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not include when-not-to-use, prerequisites, or comparisons with sibling network tools. For a tool with a destructive hint, this gap is notable.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds no further behavioral context (e.g., that the file is saved to the local filesystem, or that it does not modify the page). With annotations covering the basics, a score of 3 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 a single sentence with no wasted words. It is front-loaded and efficient. However, it could be slightly expanded (e.g., 'Save the current page as a PDF file') without losing conciseness.

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

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

For a simple tool with one optional parameter, the description is minimally adequate. However, it lacks information about the return value (does it return a path or success status?) and where the file is saved. The agent must infer from the parameter description. Given no output schema, this is a gap.

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

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

Schema coverage is 100%, and the parameter description in the schema already documents the default filename and preference for relative paths. The main description adds no additional meaning beyond what the schema provides, so baseline 3 is correct.

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 'Save page as PDF' clearly states the verb ('save') and resource ('page as PDF'), and it distinguishes from sibling tools like browser_take_screenshot (image) and browser_snapshot (HTML). However, it could be more precise by specifying that it saves the current page, not just any page.

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

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

No guidance is provided on when to use this tool versus alternatives like browser_take_screenshot or browser_snapshot. The description lacks any context about prerequisites, typical use cases, or when to avoid using 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?

Annotations already declare `destructiveHint: true` and `openWorldHint: true`, which signal state modification and external interaction. The description adds no additional behavioral context beyond what annotations provide. It does not mention that the key press targets the currently focused element, triggers events, or could be used for keyboard shortcuts. With annotations carrying the safety profile, the description adds minimal value, but does not contradict 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 sentence of 5 words, which is concise and front-loaded. There is no wasted verbiage. However, it is arguably too terse; it could include more context without becoming verbose (e.g., 'on the focused element'). The conciseness is good but not optimal for the tool's context.

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

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

Given the simple tool (1 parameter, no output schema, annotations present), the description is insufficient. It does not explain the effect (e.g., triggers a keydown/keyup event on the focused element), how it interacts with browser state, or the scope of the key press. The schema partially fills gaps, but the description alone does not provide enough context for an agent to understand the full behavior. A more complete description would mention focus dependency and event generation.

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 parameter `key` is fully described in the input schema (100% coverage) with details about key names or characters. The description 'Press a key on the keyboard' does not add any meaning beyond the schema. Following the baseline rule for high coverage, a score of 3 is appropriate since the description does not repeat or enhance the parameter semantics.

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

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

The description 'Press a key on the keyboard' clearly states the action (press) and the resource (key on the keyboard). It is specific and matches the tool name. However, it does not differentiate from sibling tools like `browser_type` (which types text sequences) or `browser_click` (mouse click), leaving ambiguity about when a single key press is intended versus other input methods. The purpose is clear but lacks sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. With 65 sibling tools including `browser_type`, `browser_mouse_click_xy`, and keyboard-related actions, an agent would have no contextual hints about preferring `browser_press_key` over `browser_type` for a single character, or over `browser_handle_dialog` for Enter/Escape. No when-to-use or when-not-to-use information is given.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, signaling a state-changing operation. The description 'Resize the browser window' is consistent with this but adds no additional behavioral details (e.g., whether it affects screenshots, triggers resize events, or requires a specific browser state). The description does not exceed what annotations already provide.

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

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

The description is a single, clear sentence with no extraneous words. It is appropriately front-loaded and efficient. However, it could be slightly expanded with minimal context without losing conciseness.

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

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

Given the tool's simplicity (2 parameters, no output schema, annotations present), the description is minimally adequate. It does not explain return values, error conditions, or the effect on the browser state, but the annotations partially compensate. The description is not incomplete to the point of being misleading, but it lacks depth.

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%; both 'width' and 'height' have descriptions. The tool description does not add any extra meaning beyond what the schema already conveys. A baseline of 3 is appropriate since the schema sufficiently documents the parameters.

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

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

The description 'Resize the browser window' clearly states the action (resize) and the resource (browser window). It is specific and distinguishes from sibling tools like 'browser_navigate' or 'browser_take_screenshot' by focusing on window dimensions. However, it does not clarify whether this resizes the viewport or the actual OS window, which could be ambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., browser_mouse_move_xy or browser_navigate). There is no mention of prerequisites, context, or exclusions. The description is purely functional with no usage context.

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

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

Annotations already provide readOnlyHint=false, openWorldHint=true, and destructiveHint=true. The description adds that execution resumes after a pause and the step parameter pauses again. It does not explain why destructiveHint is true (resuming may lead to destructive actions via the script, but the tool itself is not destructive). No contradictions are present, but the description adds limited behavioral context beyond what the annotations convey.

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

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

The description is two sentences, front-loaded with the core purpose, and wastes no words. Every sentence adds value: first defines the action, second explains the key parameter behavior. This is optimally concise and well-structured.

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

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

With two optional parameters and no output schema, the tool is simple. The description covers the general purpose and step behavior but omits the 'location' parameter entirely. Additionally, it does not specify what happens if the tool is called when execution is not paused. Given the low complexity, the description is partially complete but has noticeable 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%, so the schema already documents both parameters with descriptions. The tool description repeats the schema's explanation for 'step' but adds no new insight. The 'location' parameter is not mentioned at all. Since the baseline is 3 when coverage is high, and the description adds negligible value, the score remains 3.

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 'Resume' and the resource 'script execution', with the specific context of being 'after it was paused'. This distinguishes it from sibling browser control tools like browser_navigate or browser_click, which handle other actions. The additional sentence about step behavior further clarifies the primary use case.

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

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

The description explicitly states when to use the tool ('after it was paused') and explains the step parameter's behavior, indicating a debugging context. It does not mention when not to use it or provide alternative tools, but given the unique purpose (resuming execution), no alternatives are obvious. The context is clear and sufficient for basic usage decisions.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, so the agent knows it modifies state. The description does not add behavioral context such as route overriding, effect on existing routes, or cleanup requirements. It neither contradicts nor significantly enriches 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 sentence of 14 words with no redundancy. It is front-loaded with the core action and purpose, achieving maximum conciseness without sacrificing clarity.

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

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

Despite 6 parameters and destructive behavior, the description is too brief. It omits details like pattern matching behavior (glob syntax), response construction, cleanup requirements, and return value. The agent lacks sufficient context 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%, so the schema already documents all parameters. The description adds no additional meaning beyond mentioning the URL pattern via the tool's purpose. No parameter details are explained, but the baseline is 3 due to 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 uses a specific verb ('Set up') and resource ('route') with a clear purpose ('mock network requests matching a URL pattern'). It is distinct from sibling tools like browser_route_list (list routes) and browser_unroute (remove route), making the tool's purpose unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, when to prefer it over other network mocking tools, or when cleanup is needed. The description simply states what the tool does without context.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true. The description adds no new behavioral details (e.g., rate limits, data exposure), but it does not contradict annotations. With strong annotation coverage, the description does not need to add much, and it is consistent.

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

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

The description is a single sentence of 5 words, which is maximally concise and front-loaded. Every word is necessary and earns its place.

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

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

Given the tool has zero parameters, no output schema, and annotations cover safety and openness, the single-sentence description is fully sufficient. No additional completeness is needed for this simple list operation.

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

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

Input schema has 0 parameters, so schema description coverage is 100% (no params to cover). The description correctly omits parameter details as none exist. No additional semantic burden is required.

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 'List all active network routes' uses a specific verb (List) and resource (active network routes). It is distinct from its sibling tools like browser_route (likely routing configuration) and browser_network_requests (requests), clearly differentiating 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 briefly implies usage for inspecting active routes, but provides no explicit guidance on when to use it over alternatives like browser_network_requests or browser_network_state_set. There are no exclusions or context for when not to use it.

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

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

Annotations already flag destructiveHint=true and readOnlyHint=false. The description adds critical context that the code runs in the Playwright server process (not just the page) and is RCE-equivalent, which is beyond what annotations express. This enhances safety awareness, though it does not detail side effects or error behavior.

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

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

Two efficient sentences front-load the purpose and critical safety warning. Every word adds value with zero redundancy 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?

For a dangerous code-execution tool with no output schema, the description adequately explains what it does and the risk. However, it could be more complete by mentioning expected return values or prerequisites (e.g., a page must be open). Still, the warning is strong and the schema covers parameters well.

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% with detailed descriptions for both 'code' (including an example) and 'filename'. The tool description itself adds no additional parameter information, 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 verb 'Run' and resource 'Playwright code snippet', and warns of unsafety and RCE equivalence. This distinguishes it from sibling tools that are specific browser actions (e.g., click, navigate), making its 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 does not provide explicit guidance on when to use this tool versus alternatives. It only notes that it is unsafe and equivalent to RCE. There is no mention of preferred use cases or when to avoid it in favor of more specific browser actions like click or type.

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 no behavioral traits beyond the annotations (destructiveHint=true, readOnlyHint=false). It does not disclose side effects (e.g., triggering events, visibility requirements, or that the dropdown must be open).

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

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

The description is a single sentence, which is concise, but it sacrifices necessary detail. It is appropriately front-loaded but fails to earn its place by omitting critical information.

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

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

For a dropdown selection tool, the description is incomplete. It does not explain how to specify options, whether multiple selection is supported (the schema implies it), or what the tool expects from the page state. Schema coverage is high, but the description lacks operational context.

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

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

Schema coverage is 100%, so the baseline is 3. The description does not add meaning beyond the schema's parameter descriptions; it does not clarify what format the 'values' array should use (e.g., value attribute, label, index).

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 'Select an option in a dropdown' which clearly identifies the verb and resource, distinguishing it from siblings like browser_click or browser_fill_form. However, it does not specify whether selection is by value, label, or index, which limits precision.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., browser_click for clicking a dropdown item, browser_fill_form for input fields). There is no mention of prerequisites, context, or exclusions.

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

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

The annotations include destructiveHint: true, which already indicate the tool is destructive. The description reinforces this by stating it clears all sessionStorage, aligning with the annotation. It adds clarity beyond annotations by specifying the scope ('all sessionStorage' rather than a key), but does not detail irreversible effects or impact on page state, which is acceptable given the annotation already flags destruction.

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

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

The description is a single sentence of only three words, which perfectly captures the action with no extraneous information. It is front-loaded and efficient, well-suited for a straightforward zero-parameter tool.

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

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

Given the tool has no parameters, no output schema, and annotations cover destructiveness, the description is complete enough. It succinctly states the action and scope. No further details about return values or side effects are necessary for such a simple operation.

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

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

There are zero parameters, and the schema coverage is 100%. The description is minimal but sufficient since there is nothing to document beyond the action. The clarity that it clears all sessionStorage (without filters) is helpful but inherent in the tool's design.

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 'Clear' and the resource 'sessionStorage', which is a specific browser storage area. It distinguishes this from siblings like browser_sessionstorage_list, browser_sessionstorage_get, browser_sessionstorage_set, and browser_sessionstorage_delete, as well as browser_localstorage_clear, by targeting a different storage scope.

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

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

No guidance is provided on when to use this tool versus alternatives such as browser_sessionstorage_delete for targeted removal or browser_localstorage_clear for local storage. There is no mention of prerequisites or context, such as needing a page with sessionStorage or handling potential data loss.

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 destructiveHint=true, so the agent knows this is a destructive operation. The description adds no detail beyond that, such as whether deletion is permanent, if it triggers events, or if it requires the page to be open. The description does not contradict annotations, but adds minimal 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 a single sentence, very concise, and front-loaded with the action. No extra words, but it could be slightly more informative without being verbose.

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

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

Given the tool is simple (1 required param, no output schema, no nested objects), the description is mostly adequate. However, it lacks context about the scope (e.g., current browser tab's sessionStorage) and expected behavior if the key is missing or storage is empty. This is a minor gap for a simple tool.

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

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

Schema description coverage is 100%, with the 'key' parameter described as 'Key to delete'. The description does not add extra meaning beyond what the schema provides, such as whether the key is case-sensitive, URL-encoded, or if wildcards are supported. Baseline 3 is appropriate as schema already covers the 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 'Delete a sessionStorage item' states a clear verb-action (delete) and resource (sessionStorage item). It distinguishes from siblings like browser_sessionstorage_get, browser_sessionstorage_set, and browser_sessionstorage_clear by specifying deletion of a single item, not retrieval, setting, or clearing all.

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

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

No when-to-use or when-not-to-use guidance is provided. It does not mention that this is for browser-based sessionStorage only, when to prefer this over browser_sessionstorage_clear, or that the key must exist. No alternatives or exclusions are stated.

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

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

Annotations already declare readOnlyHint true, destructiveHint false, and openWorldHint true, so the basic safety profile is covered. The description adds no new behavioral details (e.g., it doesn't mention that the key must exist or what happens if missing). Bar is lowered due to pre-existing annotations, but no extra value is added.

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?

A single, straightforward sentence with clear structure. Front-loaded and directly informative. Still room to add contextual guidance without becoming verbose.

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

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

Given a simple tool with one required parameter and clear annotations, the description is adequate for basic usage. However, the lack of output schema or behavioral notes (e.g., return value format, error behavior) leaves mild gaps for an agent.

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

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

Schema coverage is 100% and the description of the 'key' parameter in the schema is minimal ('Key to get'). The description adds no semantics beyond what the schema provides, so the 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 it retrieves a sessionStorage item by key. The verb 'get' and resource 'sessionStorage item' are specific, and the tool is unambiguously distinguished from sibling tools like browser_sessionstorage_set or browser_sessionstorage_delete.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention browser_sessionstorage_list for listing all keys, or browser_localstorage_get for local storage. The description offers no context about prerequisites or use cases.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe, read-only nature is covered. The description adds no further behavioral context (e.g., that it lists all keys, potential performance considerations, or that an empty storage returns an empty list). Without annotations the description would be insufficient, but here it merely restates the function without adding new behavioral insights.

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

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

The description is a single, front-loaded sentence: 'List all sessionStorage key-value pairs'. Every word is necessary and contributes to clarity. No extraneous information.

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

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

For a simple list tool with no output schema, the description minimally states what it does. However, it omits details about the return format (e.g., array of objects with key/value fields), behavior for empty storage, or potential side effects. Given no output schema, the description should provide a bit more structural context to fully guide the agent.

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

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

The tool has zero parameters, and the schema description coverage is 100% (vacuous). Per rubric, a zero-parameter tool earns a baseline of 4. The description does not add parameter details (as none exist), but does not detract.

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 'List' and identifies the exact resource 'all sessionStorage key-value pairs'. This clearly distinguishes the tool from sibling tools like browser_sessionstorage_get (which retrieves specific keys) and browser_localstorage_list (which operates on localStorage).

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

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

No explicit guidance is provided on when to use this tool versus alternatives such as browser_sessionstorage_get or browser_localstorage_list. The usage is implied by the tool name and sibling context, but the description lacks statements like 'Use this to get all sessionStorage entries at once' or 'When you need a specific key, use browser_sessionstorage_get instead.'

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

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

The description does not add behavioral context beyond what annotations already provide. Annotations indicate readOnlyHint=false, openWorldHint=true, destructiveHint=true, which imply mutation and potential side effects. However, the description says nothing about what 'setting an item' entails (e.g., does it overwrite existing keys? Does it require a page to be loaded?). Without elaboration, the agent lacks critical behavioral understanding.

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

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

The description is extremely short (4 words) and front-loaded, which meets conciseness. However, it fails to provide necessary context, making it under-specified rather than effectively concise. The length is minimal, but the content is insufficient for a valuable 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?

Given the lack of output schema and low sibling differentiation, the description is incomplete. It does not explain what happens after setting (e.g., confirmation, persistence, or side effects on the page). For a mutation tool with destructiveHint=true and no output schema, more details are needed to ensure safe usage.

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

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

The input schema has 2 parameters with 100% description coverage, so the schema already describes 'Key to set' and 'Value to set'. The description 'Set a sessionStorage item' adds no further meaning beyond the schema. Baseline 3 is appropriate because the schema does the heavy lifting.

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 'Set a sessionStorage item' clearly states the action (set) and the resource (sessionStorage item). However, it does not distinguish itself from sibling tools like browser_sessionstorage_set and browser_cookie_set, all of which set storage items. The verbosity is minimal, leaving ambiguity about what 'sessionStorage' is in context.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, there is no mention that this tool is for browser session storage (not cookies or localStorage) or that it requires a page context. The description is too vague to help an AI agent 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 explicitly states the key behavioral side effect: 'This clears existing cookies and local storage before restoring.' This adds critical context beyond the { destructiveHint: true } annotation, which only indicates potential destructiveness without detailing what exactly gets cleared. The agent is thus well-informed about the tool's impact on the browser state.

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 consists of two short, clear sentences. The first sentence states the core action and resources, and the second adds the critical behavioral note. There is no unnecessary fluff or repetition; every word contributes to understanding the tool's purpose and effect.

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 simple schema (one string parameter, no output schema) and clear annotations (destructiveHint), the description is largely complete. It explains the action, resources, and a key side effect. However, it does not specify the expected format of the state file (e.g., .json, Playwright storage state format), which could cause issues if the agent needs to create such a file. This minor gap prevents a perfect score.

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

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

The schema already provides 100% coverage for the only parameter 'filename', describing its purpose and type. The description adds no new details about the parameter (e.g., expected file format, path conventions, or supported storage states). According to the rubric, with high schema coverage, baseline 3 is appropriate; the description does not improve nor detract from parameter understanding.

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

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

The description uses specific verbs 'restore storage state' and includes the concrete resources 'cookies, local storage' and the source 'from a file'. This clearly distinguishes it from siblings like browser_cookie_set or browser_localstorage_set, which operate on individual items rather than restoring a full state snapshot.

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 briefly mentions that it clears existing cookies/local storage before restoring, which implies a destructive action. However, it does not explicitly state when to use this over alternatives like browser_cookie_set or browser_localstorage_set for individual items, nor does it mention context like preparation of storage state files or typical use cases (e.g., restoring a 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 readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds the comparative claim 'better than screenshot' but does not elaborate on behavioral traits like the snapshot's content structure, depth limits, or side effects. With annotations present, this is adequate but not exceptional.

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

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

The description is a single, short sentence that front-loads the core purpose. It is efficient and free of fluff, though it could benefit from slightly more detail without becoming verbose.

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

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

The tool has no output schema, so the description should explain what an accessibility snapshot contains (e.g., element roles, names, states). It only gives a vague term. With four optional parameters and many sibling tools, the agent lacks guidance on what to expect from the output and how this tool fits into browser automation workflows.

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 (boxes, depth, target, filename) has a clear description in the schema. The tool description does not add any additional meaning beyond what the schema already provides. Baseline 3 is appropriate as the schema carries the load.

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

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

The description clearly states the tool captures an accessibility snapshot of the current page, using a specific verb ('Capture') and resource ('accessibility snapshot of the current page'). It also explicitly compares to the sibling tool `browser_take_screenshot`, distinguishing 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 implies usage by claiming this is 'better than screenshot', providing context for choosing this tool over a visual screenshot. However, it does not explicitly specify when not to use it, nor does it mention alternatives beyond the screenshot comparison. Clear context but lacks exclusions.

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

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

Annotations declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, indicating a non-destructive, idempotent read operation. The description 'Start trace recording' aligns with a non-destructive action but does not disclose details about the side-effect (e.g., tracing might affect performance, start collecting data, or require browser_stop_tracing to stop). It adds little beyond what annotations already provide, so a score of 3 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 extremely concise at only three words, which is appropriate for a tool with no parameters and a simple purpose. It is front-loaded and efficient, though adding a bit more context on tracing scope would not significantly bloat it.

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

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

Given the tool has no parameters, no output schema, and annotations already cover readOnly and openWorld aspects, the minimal description is acceptable but leaves gaps. An agent might need to know if start_tracing must be paired with stop_tracing, or what the recording captures. The description is complete enough for a basic start action but lacks the behavioral context that makes it fully actionable without experimentation.

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

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

The input schema has zero parameters and 100% schema description coverage, so there is nothing to describe. The tool requires no configuration, and the baseline for 0 parameters is 4. The description correctly implies no input is needed, and no additional parameter details are required.

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 'Start trace recording' includes a specific verb and resource, which clearly indicates the tool's basic function. However, among sibling tools like browser_stop_tracing, browser_network_requests, and browser_console_messages, it does not differentiate what kind of tracing is being started (e.g., performance tracing, network tracing, or browser tracing), leaving ambiguity about its exact 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?

The description provides no guidance on when to use this tool versus alternatives such as browser_network_requests or browser_console_messages, nor does it mention any prerequisites (e.g., whether a page must be loaded or tracing must be stopped before starting). There is no indication of context or exclusions, making it difficult 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?

Annotations indicate readOnlyHint=true and destructiveHint=false, but 'starting video recording' implies a potentially mutating state (recording resources started). The description does not disclose behavioral traits beyond annotations, such as whether recording affects browser performance, requires user permissions, or produces a file immediately. With annotations present, the low burden makes a 3 reasonable, though contradictions are absent.

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 with no wasted words. It front-loads the key action ('start video recording'), though it could benefit from additional brief context (e.g., what kind of video). The structure is efficient.

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

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

Given the tool's moderate complexity (2 parameters, nested object), lack of output schema, and context signals with no enums, the description is incomplete. It does not explain how the recorded video is used, if it starts immediately, or what the filename extension should be. Sibling tools like browser_stop_video exist but are not referenced.

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

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

Schema description coverage is 100%, so the schema already documents 'size' and 'filename' with descriptions. The description 'Start video recording' adds no additional semantic meaning beyond what the schema provides, leading to a baseline score of 3 despite no param details in the description.

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

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

The description 'Start video recording' clearly states a verb ('start') and a resource ('video recording'), which distinguishes it from siblings like browser_take_screenshot or browser_stop_video. However, it lacks specificity about what is being recorded (e.g., browser tab, entire screen) and context about the recording scope, making it only adequate.

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

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

The description provides no guidance on when to use this tool versus alternatives like browser_start_tracing or browser_take_screenshot. It does not mention prerequisites, typical use cases, or exclusions (e.g., video vs. screenshot vs. tracing), leaving the agent to infer usage from the name alone.

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

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

Description contradicts annotations: 'Stop trace recording' implies a state change, but annotations declare readOnlyHint=true, suggesting the tool does not modify state. No additional behavioral context is provided.

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

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

Extremely concise: a single seven-word sentence with no unnecessary text. Every word earns its place for a simple tool.

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

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

For a simple tool with no parameters or output schema, the description is minimal. It lacks context about prerequisites (e.g., must be used after starting a trace) and what happens if no trace is active. Adequate but not complete.

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

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

No parameters exist, so baseline 4 applies. The description does not need to add parameter details, but it adds no meaningful value beyond what the schema already conveys.

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 'Stop trace recording' clearly identifies the tool's action (stop) and resource (trace recording), distinguishing it from browser_start_tracing. It is specific but not overly detailed.

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

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

No guidance on when to use this tool vs alternatives (e.g., browser_resume is not mentioned). There is no explicit context for when to stop tracing, such as after starting a trace.

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 'Stop video recording' implies a mutating action, but annotations declare readOnlyHint=true, which states no state modification. This is a direct contradiction. The description adds no behavioral insights beyond the annotation conflict.

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

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

The description is a single sentence of three words, with no wasted content. It is front-loaded and maximally concise for the purpose conveyed.

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 the tool's simplicity, the description is incomplete due to the annotation contradiction. It fails to clarify actual behavior (e.g., whether it truly stops a recording or is a read-only operation). No output schema or further details exist to compensate.

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

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

There are zero parameters, so the schema fully covers them. Baseline for 0 params is 4. The description does not need to add parameter info, and it does not misrepresent anything.

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 'Stop video recording' clearly states the action (stop) and the resource (video recording). It is distinct from sibling tools like browser_start_video and browser_video_chapter, providing a specific verb+resource pair.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites (e.g., video must be recording) or when not to use it. The context is purely implicit.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false, so the description does not need to repeat those. The description adds value by specifying what is saved (cookies, local storage) – which is additional behavioral context beyond annotations. It does not mention file format, overwrite behavior, or what happens if the file already exists, but given the annotations this is acceptable.

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

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

The description is a single sentence (11 words) that conveys purpose, resource, and action. Every word contributes. No filler or repetition. It is front-loaded with the key verb 'Save'.

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

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

Given the tool has only 1 optional parameter, no output schema, and annotations are rich, the description is sufficient. It covers the core scenario (saving state for reuse). It could mention that the file is intended to be used with a browser_storage_state (load) tool, but the sibling set implies that. Missing: no mention of session storage, but the description says 'cookies, local storage' already. Output format is not specified but that is acceptable without an output schema.

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

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

Schema coverage is 100% (the only parameter 'filename' is fully described in the schema). The description adds no additional meaning beyond the schema – it just mentions 'Save storage state...', without elaborating on filename format, path resolution, or allowed characters. Thus 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 saves browser storage state (cookies, local storage) to a file for reuse. This is a specific verb (save) + resource (storage state) + purpose (for later reuse). It distinguishes itself from sibling tools like browser_storage_state (which would load) and other storage tools (browser_cookie_*, browser_localstorage_*, browser_sessionstorage_*). However, it does not explicitly name the complementary loader 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 description indicates when to use: before a state change that you might want to restore later ('for later reuse'). It implies 'when you want to persist the current session'. No explicit 'when not to use' or alternatives are mentioned, but the context of persistence is clear given sibling tools like browser_cookie_set etc. that modify state.

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 destructiveHint=true and readOnlyHint=false, but the description adds no extra behavioral context. It does not explain that closing a tab is irreversible, that creating a tab navigates to the given URL, or that selecting a tab changes focus. For a tool with destructive operations, this is minimal disclosure beyond what annotations provide.

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

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

The description is a single sentence listing all four actions. It is concise and front-loaded with the purpose. However, it could be slightly more structured (e.g., separating actions or noting parameter dependencies) without sacrificing brevity.

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

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

Given the tool has four actions, three parameters, and no output schema, the description is too minimal. It does not explain how parameters map to actions (e.g., url is only for 'new', index for 'close'/'select'), nor does it describe return values or side effects. The destructiveHint=true suggests more warnings are needed, but none are provided.

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 parameter descriptions in the schema already explain the meaning of url, index, and action. The description adds no new semantic information about parameters. Baseline 3 is appropriate as the schema carries the full burden.

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 does four specific operations on browser tabs: list, create, close, or select. This distinguishes it from sibling tools like browser_navigate (which navigates a page) or browser_close (which likely closes the entire browser). The verb-resource pairing is precise and unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention when to prefer browser_tabs over browser_navigate for navigation, or over browser_close for closing the browser itself. There is no 'when not to use' or comparison to sibling tools, leaving the agent to infer usage context.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool is known to be safe. The description adds a key behavioral trait: the screenshot is static and cannot be used for interactive actions. This goes beyond the annotations and provides needed context for 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?

Two sentences, no wasted words. The first sentence states the purpose, the second provides usage guidance. 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?

The description is adequate for a simple tool but lacks clarity on what happens to the screenshot (e.g., saved to file, returned). The filename parameter in the schema implies file saving, but the description does not confirm the output behavior. With no output schema, more context on the result would improve completeness. Still, the core purpose and constraints are covered.

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

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

Schema description coverage is 100%, so the parameter details are already fully documented. The description adds no additional meaning to the parameters beyond what the schema provides. 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 'Take a screenshot of the current page' with a specific verb and resource. It directly distinguishes itself from the sibling tool browser_snapshot by noting that the screenshot cannot be used for actions, providing clear differentiation.

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

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

The description explicitly tells when not to use the tool ('You can't perform actions based on the screenshot') and provides an alternative ('use browser_snapshot for actions'). This is a clear, actionable guideline that helps an agent choose the correct 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 provide destructiveHint=true (mutation) and openWorldHint=true (may affect page state). The description adds no behavioral details beyond 'Type text'. It doesn't disclose that it can press Enter after (via submit param), type slowly for key handlers (via slowly param), or that it requires element permission reference (element param). With annotations already covering mutability, description provides minimal extra 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 a single 5-word sentence 'Type text into editable element'. There is zero waste. Every word earns its place by clearly stating verb, object, and scope. Perfectly concise for such a simple tool.

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

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

Given the tool's simplicity, moderate parameter count (5), and rich sibling context, the description is minimally adequate. It lacks guidance on what happens when text contains special characters, how the element being targeted interacts with page snapshots, or what the return value indicates. However, the schema covers all parameters well, so the description doesn't need to be exhaustive.

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

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

Schema coverage is 100%, so baseline is 3. The description adds no parameter-specific context beyond what the schema already provides. It does not explain how target relates to the page snapshot or why element is needed for permissions anymore than the schema's brief descriptions already convey.

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 'Type text into editable element' has a clear verb ('Type') and resource ('editable element'), distinguishing this from siblings like browser_fill_form (which fills form fields) and browser_click (which clicks). It's specific enough for an agent to understand the basic action, though it could be more precise about targeting.

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

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

No explicit when-to-use or when-not-to-use advice is given, which is a gap given many sibling tools for typing (browser_fill_form, browser_press_key). The description implies it's for basic text entry into any editable element, but doesn't contrast with alternatives like browser_fill_form for complex form filling or browser_press_key for individual key presses.

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 destructiveHint=true, and the description adds that omitting the pattern removes all routes, which is valuable beyond annotations. No contradiction; readOnlyHint=false aligns with removal.

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

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

Single sentence, 14 words, front-loaded with the verb 'Remove'. No redundant or unnecessary text.

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

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

The description is adequate for a simple destructive action. No output schema exists, but the lack of return value information is acceptable given the tool's straightforward nature. Could optionally mention immediate effects or confirmation.

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 explains the parameter: 'URL pattern to unroute (omit to remove all routes)'. The description adds no significant additional meaning.

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

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

Description clearly states 'Remove network routes', specifying it can remove routes matching a pattern or all routes if no pattern is provided. This distinguishes it from browser_route (adds routes) and browser_route_list (lists routes).

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 says when to use: to remove specific routes by pattern or clear all routes. It does not explicitly state when not to use or mention alternatives, but the purpose is clear from 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 description claims 'Add a chapter marker' (a write/mutation operation), but the annotation readOnlyHint=true marks it as a read-only operation. This is a direct contradiction. The description also fails to disclose whether the marker is added to the recording file or just a UI overlay, and does not mention any side effects.

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

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

Two short sentences, front-loaded with the action. No unnecessary words, but it could be slightly more structured by separating purpose from effect.

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 contradiction and lack of usage guidance, the description is incomplete. It does not explain the effect of the duration parameter, the required nature of title, or how the chapter marker integrates with the video recording. The annotations contradict the description, reducing overall 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?

All three parameters are fully described in the input schema (100% coverage), so the description adds no extra meaning. 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 states a specific verb ('Add') and resource ('chapter marker to the video recording'), and distinguishes it from sibling video tools like browser_start_video and browser_video_show_actions. The visual effect ('full-screen chapter card with blurred backdrop') adds clarity.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., during recording, prerequisites like an active recording session). There is no mention of exclusions or when not to use it.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false. The description adds behavioral context by stating it stops annotations on the page, which goes beyond the annotations. No contradictions.

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

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

Single sentence, six words, front-loaded. Every word 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 no parameters, no output schema, and clear annotations, the description is nearly complete. It could briefly mention that existing annotations are removed or hidden, but the current text is sufficient for an agent to understand the 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?

The tool has zero parameters and schema coverage is 100% (no properties). The description correctly adds no parameter information because none is needed. This is a baseline 5 for a no-parameter tool.

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

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

The description uses a specific verb 'stop' and resource 'annotating actions performed on the page', clearly distinguishing it from sibling tools like browser_video_show_actions (which would start annotations).

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

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

The description implies the tool is used to stop annotations, but does not explicitly state when to use it versus alternatives like browser_hide_highlight or browser_annotate. No usage exclusions or alternatives 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?

Annotations already declare `readOnlyHint: true` and `destructiveHint: false`, so the agent knows it's safe. However, the description adds minimal behavioral context beyond 'annotate subsequent actions' – it doesn't explain how it detects actions, whether it requires an ongoing video recording, or what happens if used without recording. For a tool that modifies visual display, more behavioral disclosure would be valuable.

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 core action, no wasted words. Every sentence adds distinct value: the first defines the action, the second gives the use case.

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

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

Given the tool's low complexity (3 optional parameters, no output schema, read-only), the description is mostly complete, covering purpose and high-level context. However, it lacks explanation of prerequisites (e.g., whether video recording must be active) and how the tool interacts with the recording process, which would be valuable for a visual annotation tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level information beyond what the schema already provides. The schema itself documents each parameter well (cursor types, duration unit, position options), so the description doesn't need to compensate.

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

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

The description uses a specific verb ('Annotate') and resource ('subsequent actions performed on the page'), and explicitly states the use case ('while video recording or screencasting'). It clearly distinguishes from sibling tools like `browser_video_hide_actions` and `browser_annotate`.

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

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

The description clearly states this is for video recording or screencasting contexts, providing a clear use case. However, it does not explicitly mention when NOT to use this tool or suggest alternatives, though the sibling tool `browser_video_hide_actions` strongly implies the counterpart.

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

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

Annotations already indicate readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering safety. The description adds only the basic waiting behavior but omits critical details like polling mechanism, timeout behavior, or what happens if text never appears/disappears. This is insufficient for a blocking operation.

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