playwright-browser-skill

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it reveals nothing about how the tool behaves. It does not mention whether the script tag executes, what happens if both url and content are provided, or any side effects on the page.

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, but this is under-specification rather than efficient conciseness. It merely repeats the tool's name without earning its place by adding any useful information.

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

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

Given the tool's complexity (two parameters, potential injection behavior) and the absence of annotations and output schema, the description is wholly inadequate. It lacks essential context about how url and content are used, whether scripts are executed immediately, and any security considerations.

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 description coverage, and the description does not explain the meaning or usage of the 'url' and 'content' parameters. The parameter names are self-explanatory to some degree, but the description adds no semantic value beyond the raw 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 '添加脚本标签' translates directly to 'Add script tag', which merely restates the tool's name in another language. It provides no additional detail about what the tool actually does beyond the name itself, making it a tautology rather than a meaningful explanation.

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 or how it relates to alternatives like browser_add_style_tag. There is no mention of use cases, prerequisites, or conditions under which this tool should be preferred.

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?

There are no annotations, and the description offers no behavioral details such as whether the style tag is injected into the current page or the URL specified, whether it overrides existing styles, or any side effects. This is a significant gap for a mutation tool.

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

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

The description is extremely short (five characters), but this is under-specification rather than efficient conciseness. It lacks essential information while being brief, which fails the tool's usability.

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 parameters, no output schema, and no annotations, the description is woefully incomplete. It does not explain the role of url versus content, whether content is required, or what happens on execution. This is insufficient for an agent to invoke the tool correctly.

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

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

The input schema has two parameters (url and content) with 0% description coverage, and the tool description does not explain what these parameters mean. The description fails to compensate for the lack of schema context, leaving the agent guessing about required fields and formats.

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 '添加样式标签' (Add style tag) clearly states the operation (adding a style tag) and the resource (style tag). It is specific enough to understand the general purpose, though it does not distinguish from its sibling browser_add_script_tag beyond the style/script difference.

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, whether it requires a loaded page, or how it differs from alternatives like browser_add_script_tag. The description merely states the action without any contextual 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?

No annotations exist, and the description offers no behavioral details beyond the verb. It does not disclose what 'blocking' entails (e.g., permanent cancellation, matching rules, reversibility, side effects on navigation). The description fails to convey any operational nuances.

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 (two characters), but this is under-specification rather than conciseness. It lacks any structural detail, such as parameter explanation or usage context, so the brevity is not a strength.

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 one complex parameter, no annotations, no output schema, and limited sibling differentiation, the description is grossly inadequate. An agent would have to guess the behavior and parameter format, risking incorrect invocation.

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

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

The schema has one parameter 'patterns' with no description, and the tool description adds no meaning. It is unclear whether patterns are URL globs, regex, or exact strings. With 0% schema coverage, this is a critical gap.

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

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

The description '拦截请求' (block requests) names a specific action and resource, making the core purpose clear. However, it does not distinguish this from sibling tools like browser_mock_response or browser_wait_for_request, which could overlap in intent. The brevity makes it unambiguous but not differentiating.

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. The description gives no context about typical use cases, prerequisites, or scenarios where blocking requests is appropriate. Sibling tools with related functionality (e.g., mock_response) 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?

With no annotations, the description carries the full burden of behavioral disclosure. It fails to explain side effects, whether the checkbox must be visible, error handling, or if it waits for actionability. The minimal description gives no insight into the tool's runtime behavior.

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

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

The description is extremely short, but it is under-specified rather than concise. It lacks essential details, and a single phrase does not adequately explain the tool's function or usage.

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

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

Despite having only one parameter and no output schema, the description is incomplete. It provides no information about return values, side effects, or interaction with the browser context, making it insufficient for an agent to use the tool correctly.

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

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

The schema has one required parameter 'selector' with no description, and schema description coverage is 0%. The description does not mention the selector or how it is used to locate the checkbox, leaving the parameter's purpose completely unexplained.

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 '勾选复选框' translates to 'check the checkbox', which provides a specific action and object but does not differentiate from sibling tools like browser_click or browser_tap. It essentially restates the tool's name with minimal elaboration, lacking context about the page or element 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 such as browser_uncheck, browser_click, or browser_tap. There is no mention of prerequisites, conditions, or scenarios where this tool is preferred.

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

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

With no annotations, the description carries the full burden but only repeats the tool name. It does not disclose whether this clears all cookies in the browser context, whether it affects persistent storage, or any destructive side effects, leaving the agent without important behavioral context.

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

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

The description is a single short phrase with no filler or redundant content. It is front-loaded and appropriately minimal for a tool with no parameters, though it could be slightly more informative.

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

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

The description is too minimal for a browser mutation action. It lacks context about the scope of the cookie clearing, relationship to other storage operations, and any caveats. With no annotations and no output schema, the agent is left without essential operational details.

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

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

The tool has zero parameters, so the schema coverage is complete and the description has no parameter semantics to add. The baseline of 4 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 (清除Cookie = clear cookies) with a specific verb and resource. It distinguishes from siblings like get_cookies and set_cookies, though the text itself is essentially a restatement of the tool name and provides no additional scope 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?

There is no guidance on when to use this tool versus alternatives such as browser_set_cookies, browser_get_cookies, or browser_clear_local_storage. The agent is given no decision-making context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. However, it merely states 'clear geolocation' without explaining effects, side effects, or the fact that it resets geolocation to system default or removes a mock override. This provides no transparency beyond the name.

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

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

The description is a single short phrase, which is structurally simple and concise. However, the brevity is a form of under-specification rather than effective conciseness, as it omits all contextual information. It is not verbose, but it does not earn its place by adding value.

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

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

For a tool with no parameters and no output schema, the description still fails to explain what 'clearing geolocation' means in the browser automation context. It does not mention the relationship to browser_set_geolocation or the resulting state, leaving the agent to infer behavior. This is incomplete even 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?

The tool has zero parameters and schema coverage is 100% (empty schema). There is nothing to add about parameters, so the baseline of 4 is appropriate.

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

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

The description '清除地理位置' is a direct Chinese translation of the tool name 'browser_clear_geolocation', restating the action without adding any new detail. It is essentially a tautology and does not distinguish itself from other browser-related tools beyond the name itself.

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, when not to, or any alternatives. It lacks context about clearing geolocation overrides set by browser_set_geolocation or any usage prerequisites.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the action, but does not disclose that clearing localStorage is irreversible, affects the current origin, or could impact page state. The destructive nature is implied but not elaborated.

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

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

The description is exceptionally concise, using only two words with no wasted text. It earns its place by being direct. However, it is a fragment rather than a sentence, and the use of Chinese may reduce clarity for some agents, so it is not a full 5.

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 (no parameters, no output schema), the description is mostly complete in terms of what it does. However, it lacks behavioral context such as scope (current origin), irreversibility, and potential side effects. For a mutation tool, this is a noticeable gap.

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

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

The tool has zero parameters, and the schema coverage is trivially 100%. Per the rubric, 0 params warrants a baseline of 4. The description does not need to explain parameters because there are none.

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 '清除LocalStorage' directly translates to 'Clear LocalStorage', which clearly states the specific verb (clear) and resource (LocalStorage). This distinguishes it from sibling tools like browser_get_local_storage or browser_set_local_storage. The purpose is 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 usage guidance is provided. The description only states the action without any context on when to use this tool versus alternatives like browser_clear_cookies or browser_get_local_storage. There are no explicit conditions, prerequisites, or exclusions.

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

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

No annotations exist, so the description carries the burden. It discloses the destructive nature ('clear') and scope ('all logs'), but does not detail exactly which log types are affected or whether the action is irreversible. Minimal but adequate.

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

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

The description is a single short phrase, perfectly sized for a parameterless tool. It is front-loaded and free of superfluous content.

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

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

For a simple no-parameter clear operation, the description is mostly complete, but it could benefit from specifying which log categories (console, network, request/response) are cleared to remove ambiguity.

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

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

The tool has no parameters, so the empty schema is fully covered. The description provides all necessary contextual meaning; no parameter descriptions 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 uses a specific verb '清除' (clear) and resource '所有日志' (all logs), clearly distinguishing it from the many get-log sibling tools. It is concise and unambiguous in intent.

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 simply states the action. There is no mention of prerequisites, conditions, or that it should be used after inspecting logs.

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

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

With no annotations, the description carries the full burden of behavioral transparency. It fails to disclose what permissions are cleared, whether it clears all permissions or a subset, whether it affects the current page or the entire browser session, or any side effects. The word 'clear' implies mutation, but no specifics are given.

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, but this is under-specification rather than effective conciseness. It consists of just two Chinese characters that add no value beyond the tool name. It is not appropriately sized because it omits essential information that would help an agent understand the tool's purpose.

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

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

Given the lack of annotations and output schema, the description should fully explain the tool's behavior. 'Clear permissions' is a vague phrase that leaves the agent unsure about scope, side effects, and relationship to other permission-related tools. This is completely inadequate for a tool that could have significant impact.

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 baseline is 4. The description adds no parameter information, but none is needed because there are no parameters to document. The empty schema fully covers the parameter space, so no gap exists.

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 '清除权限' is a direct Chinese translation of the tool name 'browser_clear_permissions', making it a tautology. It restates the name without providing any additional specificity about what 'permissions' means in this context. It does not distinguish itself from sibling tools like browser_clear_geolocation or browser_clear_cookies.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention the related browser_grant_permissions sibling or explain under what circumstances clearing permissions is appropriate. There is no hint of exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden. The description only states the action without disclosing behavioral traits such as whether the tool waits for the element to be actionable, whether it moves the mouse, what the default button is, or how it handles hidden elements. This is a significant transparency gap.

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

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

While the description is very short, it is under-specified rather than concise. It omits critical information about parameter usage and behavior, so it does not earn a higher score for efficiency.

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 (4 parameters, no annotations, no output schema), the description is severely incomplete. It fails to explain return values, default behaviors, or usage context, making it nearly impossible for an agent to use the tool correctly based on the description alone.

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

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

The schema has no descriptions (0% coverage), and the description does not compensate by explaining any parameters. The four parameters (selector, button, timeout, clickCount) are not mentioned at all, leaving the agent to infer their meaning solely from names and enums.

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 '点击元素' (Click element) clearly states the primary action: clicking an element. It is a specific verb+resource pairing, but it does not differentiate from closely related sibling tools such as browser_mouse_click, browser_dblclick, or browser_tap, all of which involve clicking.

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. The description provides no context regarding prerequisites, typical scenarios, or distinctions from sibling tools like browser_mouse_click or browser_tap.

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

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

No annotations are present, so the description must disclose side effects. It only says 'close browser' without mentioning that it closes all pages, terminates the connection, or may cause data loss. This is a significant gap.

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

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

A single concise phrase '关闭浏览器' communicates the action with zero wasted words. It is appropriately sized for a parameterless, simple operation.

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

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

Given the tool's simplicity (no params, no output schema), the description is fundamentally adequate but lacks behavioral context such as irreversible effects or what happens to open pages. This leaves some ambiguity 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?

The tool has no parameters and the schema already provides 100% coverage (empty properties). With zero parameters, the description need not add parameter details; baseline 4 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 states '关闭浏览器' (close browser), a specific verb and resource. It clearly distinguishes from sibling 'browser_close_page' by targeting the entire browser rather than a 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 on when to use this tool versus alternatives like browser_close_page. It does not mention end-of-session context or whether this is required after closing all pages.

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

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

With no annotations, the description carries the full burden of disclosing behavior, but it merely states 'close specified page'. It does not mention consequences such as whether closing the current page switches to another, whether the index is zero-based, or any irreversible effects. This is a destructive operation with minimal safety disclosure.

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 fluff, but it is under-specified. It earns its place minimally, yet it sacrifices clarity for brevity. The structure is clean but misses crucial details about the parameter and behavior.

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

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

The tool is simple (one parameter, no output schema), but the description is too thin for reliable use. It lacks essential context about how to identify the page, what happens after closing, and any side effects. Given the destructive nature, more detail is required for safe operation.

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

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

The input schema has a single parameter `index` of type number, but neither the schema nor the description explains its meaning (e.g., zero-based page index, tab order, or internal identifier). With 0% schema description coverage, the description should have compensated, but it stays silent. The agent cannot determine what value to supply.

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 identifies the action (close) and resource (specified page), and the parameter `index` in the schema indicates which page. It distinguishes from `browser_close` which likely closes the entire browser. However, it could be more explicit about the page being identified by index.

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_close`, `browser_new_page`, or `browser_switch_page`. The description does not mention any prerequisites, typical scenarios, or exclusions, 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?

With no annotations, the description carries the full burden for behavioral disclosure. It does not mention return format (e.g., a number), edge cases like zero matches, selector validity, or any side effects. '统计元素数量' is too terse to convey meaningful behavioral traits beyond the basic action.

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

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

The description is extremely concise with zero wasted words, but it is under-specified to the point of bordering on a tautology. It lacks structure that would help an agent understand scope or expected behavior, so it is not appropriately sized for effective use.

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 one parameter, no output schema, and no annotations, the description should provide at least basic usage context. It does not mention return value, selector type (CSS vs other), or any exceptions. For a simple count tool, this is incomplete though not completely useless.

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

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

Schema description coverage is 0%, and the description does not compensate. The 'selector' parameter is not explained in the description, leaving its format or semantics entirely to inference. The description adds no meaning beyond the schema's bare type declaration.

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 '统计元素数量' (Count the number of elements) clearly states the core action and resource. It distinguishes from sibling tools like browser_get_text or browser_click, but it does not explicitly mention the selector parameter or that the count applies to matching elements, so it lacks full specificity.

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 any mention of prerequisites or context. It merely states what the tool does without any usage notes.

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

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

No annotations exist, so the description must carry the full burden. It does not disclose behavior such as whether the element must be visible, what happens on error, or if any side effects occur. The action is straightforward but underspecified.

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 phrase with zero filler words. It is well-suited for a simple action and wastes no characters.

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 only one parameter, no annotations, and no output schema, the description is too minimal to be complete. It does not mention return values, error behavior, or when a double-click is preferable, leaving the agent to infer critical 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 description coverage is 0%, and the description does not elaborate on the 'selector' parameter. The parameter name suggests a selector, but the format (CSS, XPath, etc.) is not clarified, so the description adds minimal value 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 '双击元素' (double-click element) clearly states the action (double-click) and resource (element). It implicitly distinguishes from siblings like browser_click by specifying the double-click action, though it does not explicitly name an alternative.

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_click or browser_hover. The description only states the action without 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?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It fails to mention side effects such as triggering a browser download, whether it waits for the download to complete, any permission requirements, or how it interacts with the page. The description is a bare label with no operational detail.

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, which could be seen as concise, but it is under-specified to the point of being a restatement. There is no front-loaded useful detail, and it does not earn its place by adding value beyond the tool name.

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

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

Given the tool's apparent function (triggering a file download via a DOM selector), the description provides no information about return values, download behavior, waiting logic, or error conditions. With no output schema and no annotations, the description is wholly inadequate for an agent to invoke 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?

The schema has a single parameter 'triggerSelector' with no description, and schema description coverage is 0%. The description does not explain what the selector refers to or how it is used to initiate a download, leaving the agent to guess the parameter's semantics entirely.

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 '下载文件' (Download file) is essentially a restatement of the tool name, providing no additional detail about what file is downloaded or how. It does not differentiate from sibling tools like browser_upload_file beyond the obvious inverse action, and the 'triggerSelector' parameter suggests it triggers a download via a UI element, which is not 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?

There is no guidance on when to use this tool versus alternatives. It does not explain that it requires a selector to trigger a download, nor does it mention any prerequisites or scenarios where it should be preferred over other browser 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It does not mention that a drag-and-drop involves source and target selectors, what events are triggered, or any side effects. The one-word description offers no insights beyond what the tool name already implies.

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

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

The description is an under-specified fragment rather than a concise explanation. It provides zero information beyond the tool name and is not adequately structured to inform the agent in any meaningful way.

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 complete lack of annotations, output schema, and any parameter explanation, this description is entirely inadequate. An agent would have no way to understand how to invoke browser_drag correctly, what the two selectors are for, or what outcome to expect.

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 defines sourceSelector and targetSelector as required strings, but the description does not explain their purpose or how they relate to the drag operation. Since schema description coverage is 0%, the description should compensate, but it fails to add any meaning to 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 '拖拽元素' simply translates to 'drag element', which is a tautology of the tool name 'browser_drag'. It does not specify that this is a drag-and-drop operation between source and target selectors, nor does it distinguish it from other browser interaction tools like browser_mouse_move or browser_click.

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

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

No guidance is given on when to use browser_drag versus other browser_* tools. The description provides no context about the operation's purpose or when it should be preferred, leaving the agent without any decision support.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states 'emulate media type' without explaining side effects, persistence, or how it affects rendering. It also omits the colorScheme functionality entirely.

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 brief (single phrase), which is concise but under-specified. It earns its place by stating the core action, but lacks the structure to convey additional context expected for a tool with two parameters.

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 two parameters, no annotations, and no output schema, so the description should provide adequate context. It only covers the 'media type' aspect and omits 'colorScheme', and gives no hint about when or why to use this tool in 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 description coverage is 0%, so the description must compensate for parameter meaning. It doesn't mention either 'media' or 'colorScheme', leaving the enums to self-explain. The schema is somewhat clear, but the description adds no value in explaining 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 '模拟媒体类型' (emulate media type) uses a specific verb and resource, indicating the tool's general purpose. However, it doesn't differentiate from other browser tools or mention the colorScheme parameter, leaving the full scope unclear.

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

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

No guidance is provided on when to use this tool versus alternatives, nor are any exclusions or prerequisites mentioned. The description simply states the action without contextualizing it among sibling browser tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the core action. It doesn't mention return values, page context access, side effects, or whether the script is executed in the main world, leaving significant behavioral ambiguity.

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 brief and front-loaded, using only five characters to convey the core purpose. It wastes no words, though its brevity leaves out valuable details; this is concise but arguably 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 low complexity, minimal description might suffice, but the absence of annotations and output schema means the description should provide more context about return values, execution environment, and relationship to siblings. The current text is too thin for reliable agent selection and 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 0%, and the description adds no meaning for the 'script' and 'arg' parameters. The agent receives no explanation of what 'arg' is used for or how the script should be formatted, completely failing to compensate for the schema's silence.

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 'Execute JavaScript code' clearly states the verb and resource, establishing what the tool does. It is specific enough to distinguish from most sibling tools, though it doesn't explicitly differentiate from related tools like browser_wait_for_function or browser_add_script_tag.

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 context, prerequisites, or exclusions, 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?

With no annotations provided, the description carries full responsibility for disclosing behavioral traits. It does not mention side effects, whether it mutates state, what 'fast forward' actually does (e.g., advances a clock, speeds up animations), or any safety implications. It is entirely opaque.

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, but this is under-specification rather than effective conciseness. The sole sentence adds no valuable information beyond the tool name and thus does not 'earn its place'. The lack of structure or elaboration makes it insufficient.

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

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

Given no annotations, no output schema, and one poorly documented parameter, the description should provide comprehensive context. It provides none, leaving the tool's behavior, expected inputs, and return values completely unclear. It is inadequate for an agent to use correctly.

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

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

The single parameter 'time' is required but the schema description coverage is 0%. The description does not explain what 'time' represents, its units, domain, or effect. Since the description does not compensate for the missing schema documentation, the agent cannot understand how to set this parameter correctly.

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

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

The description '快进时间' simply restates the tool's name ('fast forward time') without clarifying what specific action is performed or what resource is affected. It does not distinguish this tool from sibling browser_go_forward, which is about history navigation, nor does it explain the intended time-related operation.

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

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

The description provides no guidance on when to use this tool or how it differs from alternatives. There is no mention of scenarios, prerequisites, or exclusions, leaving the agent without any basis for selecting this tool over similar ones.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. The phrase '填写表单' merely restates the tool name and does not reveal behaviors like whether it replaces existing values, triggers events, or works on hidden elements. This is a critical gap for an interaction 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?

While the description is extremely short (four Chinese characters), it is under-specification rather than conciseness. It omits necessary details and does not earn its place with substantive content. A concise description should still convey key information.

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

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

Given the tool has two required parameters, no annotations, and no output schema, the description needed to explain behavior and parameters. Instead, it provides only a generic verb phrase, leaving the tool's actual operation and usage completely ambiguous. It is inadequate even 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?

The input schema has two required strings (selector, value) with zero description coverage. The description does not explain what the selector refers to (e.g., CSS selector, XPath) or what value means in context. It adds no meaning beyond the raw 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 '填写表单' translates to 'fill out form', which provides a general verb+resource but is vague. It doesn't specify that it sets a value for a specific element via selector, nor does it differentiate from sibling tools like browser_type or browser_select which also interact with form elements.

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

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

The description offers no guidance on when to use this tool versus alternatives. It simply states 'fill out form' with no context, exclusions, or mention of sibling tools. There is no information about prerequisites or scenarios where this tool is preferred.

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

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

With no annotations and a two-character description, the tool's behavior is completely undisclosed. The description does not explain any side effects, what 'focus' does in the browser context, or whether it requires element visibility or other conditions.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. It lacks any useful structure or elaboration, offering only a tautological phrase that adds no value.

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

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

Given the tool's simplicity, the description still fails to cover essential context: what focusing accomplishes, when to invoke it, or how the selector should be formatted. With dozens of sibling tools, this lack of context makes correct selection and invocation highly ambiguous.

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

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

Schema description coverage is 0% and the description provides no additional meaning for the 'selector' parameter. The parameter name alone is insufficient, as the description does not clarify the expected format (e.g., CSS selector) or any constraints.

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 '聚焦元素' translates to 'Focus element', which directly restates the tool name 'browser_focus' without adding scope or distinguishing details. It specifies a verb and resource but offers no context about what focusing entails or how it differs from similar tools like browser_click or browser_hover.

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 about when to use this tool versus alternatives. There is no mention of scenarios, prerequisites, or exclusions, leaving the agent entirely without 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'get accessibility snapshot' and does not reveal output format, whether the operation is read-only, or any side effects. This is insufficient for an agent to predict tool behavior.

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

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

The description is extremely short and contains no wasted words, but this is under-specification rather than concise clarity. It offers zero explanatory content beyond the tool's name, so it fails as a useful 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?

For a tool with no annotations, no output schema, and a single undocumented parameter, the description is wholly inadequate. The agent cannot determine what an accessibility snapshot contains, how the selector influences the result, or what the return value looks like.

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 defines one optional 'selector' parameter with no description, and schema description coverage is 0%. The tool description does not mention the selector at all, so the agent is left guessing what the parameter does and how to use 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 '获取无障碍快照' is simply the Chinese translation of the tool name 'browser_get_accessibility_snapshot', restating the name without adding any explanatory value. It fails to clarify what an accessibility snapshot is, what it includes, or how it benefits the agent.

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 any of the many sibling browser tools. There are no use cases, prerequisites, or exclusions mentioned, leaving the agent without decision-relevant information.

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

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

With no annotations available, the description carries the full burden of behavioral disclosure. It only states the basic action without revealing what the list contains (e.g., page IDs, URLs), whether it includes all windows/tabs, or if there are any side effects. This is insufficient for a tool with no output schema.

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

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

The description is a single short, front-loaded phrase with zero wasted words. For a getter with no parameters, this level of conciseness is appropriate and earns a high score.

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

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

The tool has no annotations, no output schema, and a very terse description. The description does not specify the return format or any behavioral nuance, leaving the agent to guess what 'all pages' means and how to use the result. This is incomplete for a tool that provides no other structured metadata.

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

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

The tool has zero parameters, and the schema is an empty object with 100% coverage. Per the rubric, a 0-parameter tool gets a baseline of 4 since there are no parameter semantics to clarify. The description adds no parameter information because none exists.

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

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

The description '获取所有页面列表' clearly states a verb ('get') and a resource ('all pages list'), making the purpose reasonably specific. However, it does not explicitly differentiate this from sibling getters like browser_get_current_url or browser_get_frames, though the resource is distinct enough to avoid confusion.

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 context, exclusions, or relationships to other page-management tools such as browser_switch_page or browser_new_page.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states that the tool gets an element attribute. It does not mention return value format, error behavior (e.g., when selector or attribute is invalid), or whether the attribute value is a string or null. This lack of detail is a gap for a read operation.

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

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

The description is a single, short phrase with no wasted words. It is front-loaded and immediately clear. However, it essentially restates the tool name, so it earns a 4 rather than 5 for adding minimal new structural value.

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

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

Given the simplicity of the tool and the lack of an output schema, the description should explain at least what is returned (the attribute value) and any caveats about selector usage. It does neither, making the description incomplete for an agent that lacks prior knowledge of browser automation conventions.

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

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

Schema coverage is 0%, so the description must compensate. It implicitly maps 'element' to the 'selector' parameter and 'attribute' to the 'attribute' parameter, which provides basic semantics. However, it does not specify the selector syntax (CSS/XPath) or attribute name expectations, so the compensation is minimal but not absent.

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 element attribute') clearly states the action (get) and the resource (element attribute), distinguishing it from sibling getters like browser_get_text, browser_get_html, and browser_get_title. The verb and object 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?

The description provides no guidance on when to use this tool versus alternatives such as browser_get_text or browser_get_html. There is no mention of context, prerequisites, or exclusions, 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?

There are no annotations, so the description carries the full burden. It gives no details about return behavior, error handling, waiting for elements, or whether the element must exist. This is a minimal factual statement without behavioral context.

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

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

The description is extremely short, but it is under-specification rather than appropriate conciseness. It essentially restates the tool name and lacks necessary details, so the brevity does not improve understanding.

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 2 parameters, no output schema, and no annotations, the description is inadequate. It does not explain expected return value, behavior with multiple matches, or how 'exact' affects matching. This is insufficient for an agent to invoke the tool confidently.

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

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

Schema description coverage is 0%. The description mentions 'alt text' which loosely maps to the 'text' parameter, but does not explain the 'exact' parameter at all. It adds no meaningful insight beyond what the param names already imply.

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

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

The description states the tool finds elements by alt text, which is a specific action and resource. It distinguishes itself from sibling tools like get_by_text or get_by_label by mentioning 'alt text'. However, it does not clarify whether it returns a single element, list, or locator.

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 this tool over alternative locator strategies (e.g., get_by_role, get_by_text) or any edge cases for the 'exact' parameter. It only states the basic action.

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

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

No annotations are present, so the description carries full responsibility. It discloses only that the tool finds an element by label, omitting critical behaviors: whether it returns a single element or waits for multiple, how 'exact' affects matching, error handling when no element is found, or whether it performs an implicit wait. The description is behaviorally opaque.

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, which is superficially concise, but it is under-specified. It contains no front-loaded meaningful content beyond the name's translation. The lack of essential information makes it more an abridgement than a concise, well-structured 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 complex domain (browser automation with many locator strategies), no annotations, and no output schema, the description is grossly incomplete. It fails to cover return types, selector semantics, parameter effects, or edge cases. It provides barely enough information to infer the tool's basic purpose, let alone use it correctly.

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

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

Schema description coverage is 0%, and the description does not mention the 'text' or 'exact' parameters or explain their roles. It adds no value beyond the schema's bare parameter names. The description should compensate for the missing parameter documentation, but it does not.

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 '通过标签查找元素' (find element by label) essentially restates the tool name 'browser_get_by_label'. It provides no additional specificity about what 'label' means, how it differs from sibling locator tools, or what 'get' implies (returning an element handle). This is a tautology rather than a clarifying statement.

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 instead of alternatives like browser_get_by_text, browser_get_by_placeholder, or browser_get_by_title. There is no mention of label semantics, exact matching behavior, or fallback options. The agent receives no decision-support information.

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

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

No annotations are provided, so the description carries the full burden. It only states the core action and gives no information about matching behavior (exact vs. substring), what happens with multiple matches, error handling, or the return format. The 'exact' parameter hints at a matching mode, but the description does not address it.

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 short sentence that is front-loaded and easy to parse. However, the brevity comes at the cost of omitting essential details, so it is concise but under-specifying.

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 large family of sibling locator tools and the absence of an output schema, the description is insufficiently complete. It does not explain return values, matching behavior, or how to choose among the get_by_* variants. The two parameters are also poorly documented.

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

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

Schema description coverage is 0%, and the description does not explicitly describe the parameters. It implies that 'text' is the placeholder value, but the 'exact' parameter's meaning and effect are completely undefined. The description adds minimal semantic value beyond the parameter names.

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

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

The description clearly states "Find element by placeholder" – a specific verb and resource with the placeholder attribute as the locator. This distinguishes it from sibling locator tools like get_by_role or get_by_text, though it does not explicitly name any 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?

No guidance is provided on when to use this tool versus the many other get_by_* locator tools. There are no prerequisites, exclusions, or alternative suggestions. The intended use case is only implied by the tool name and description.

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

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

No annotations are provided, so the description must cover behavioral traits. It only states the basic function, omitting details like whether it returns the first match, what happens if no element is found, whether it waits for the element, or if it returns a locator handle. This is a significant gap for an interactive browser tool.

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

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

The description is a single, short sentence that is front-loaded and to the point. No wasted words, and it immediately communicates the essential action and criteria.

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 no annotations, the description is insufficient for an agent to use it reliably. It lacks usage context, return value expectations, and error behavior. While it names the key parameter, it does not provide enough to distinguish effective use from misuse.

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

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

With 0% schema description coverage and only two parameter names ('name' and 'role'), the description adds minimal value. It clarifies that the tool locates by 'role' but does not explain the purpose of the 'name' parameter (e.g., accessible name filter). The description does not compensate for the lack of schema details.

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

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

The description '通过角色查找元素' (Find element by role) clearly states a specific action (find element) and a specific method (by role), distinguishing it from sibling tools like browser_get_by_text or browser_get_by_label. It conveys the core purpose without ambiguity.

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

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

The description provides no information about when to use this tool instead of alternatives. There is no mention of ARIA roles, accessibility considerations, or comparison with other get_by_* locators, leaving the agent without guidance on tool selection.

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

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

With no annotations and no behavioral details, the description is a bare statement of intent. It does not disclose what happens if no element is found, whether it returns a handle or locator, or whether it waits for the element. The phrase adds no insight beyond the tool's name.

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

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

The description is a single short phrase with no superfluous words. It is front-loaded and immediately communicates the core purpose, making it highly concise and structurally 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 tool is simple but has no annotations or output schema, yet the description does not explain return values, error behavior, or the context of element lookup (e.g., current page or frame). This leaves significant gaps for an AI agent attempting to use the tool correctly.

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

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

The schema has one required parameter 'testId' with no type description, and schema description coverage is 0%. The description only repeats that the element is found 'by test ID', adding minimal meaning about what the parameter represents. It does not explain the format, attribute, or matching behavior expected for testId.

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 '通过测试ID查找元素' (Find element by test ID) clearly states a specific action (find) on a specific resource (element) using a specific locator strategy (test ID). This distinguishes it from sibling get_by_* tools like get_by_role or get_by_text, which use different locators.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or comparative context to sibling locator tools, leaving the agent to infer usage from the tool 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?

With no annotations, the description carries the full burden, but it only says 'find element by text'. It does not disclose whether matching is exact or substring, case sensitivity, whether it returns the first match or all, or what happens if no element is found. This is a significant gap for a locator tool.

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

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

The description is a single short phrase, which is concise, but it lacks sufficient structure and information. It is under-specified rather than properly concise; a few additional sentences could clarify behavior without bloating.

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 annotations and output schema, and the existence of many sibling locator tools, the description is incomplete. It does not explain the return value, the exact parameter semantics, or how this tool differs from get_by_title or get_by_role. An agent would be uncertain when to select this tool and how to use it correctly.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It only reiterates 'by text', leaving the 'exact' boolean parameter completely unexplained. The agent cannot know what 'exact' controls (e.g., case sensitivity, substring matching) without additional context.

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

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

The description states the tool finds an element by text, which is a clear verb+resource. However, it does not distinguish from sibling tools like get_by_role, get_by_label, etc., which also locate elements by different criteria.

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. It does not mention that it is specifically for text-based lookup or when other locators would be more appropriate. The user must infer usage from the name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It merely states 'find element by title attribute' and does not mention whether it returns a locator, waits for the element, handles multiple matches, or errors if not found. No behavioral details are disclosed.

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

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

The description is a single short sentence, but it largely restates the tool name ('find element by title attribute'), adding little value. It is under-specified rather than appropriately concise, and the brevity wastes the opportunity to provide needed 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 tool has 2 parameters, no output schema, and no annotations, the description is incomplete. It does not explain what the tool returns, how exact matching works, or any error/edge-case behavior. A single-phrase description is insufficient for a selectable element lookup 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 0%, so the description should compensate. It hints that 'text' refers to the title value, but the 'exact' boolean parameter is not explained at all. The parameter semantics are only partially clarified.

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 '查找' (find) and the resource '元素' (element) via the 'title' attribute, which distinguishes it from sibling get-by-* tools (e.g., get_by_text, get_by_label). Even though it's brief, the purpose is unambiguous and specific to the title attribute.

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_get_by_text or browser_get_by_label. The only implied usage is 'by title attribute', but no exclusions or context 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the tool's function and gives no details about whether the operation is read-only, what the logs contain, if it clears logs, or any side effects. This is a complete lack of 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 short phrase, but this is under-specification rather than conciseness. It provides no structural value, no front-loaded key information, and lacks any sentences that earn their place beyond repeating the name.

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

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

Given no output schema and no annotations, the description is the only source of context. It fails to explain what the return value looks like, how the limit parameter behaves, or how this tool fits into the broader browser automation context. A getter tool that is part of a large sibling set needs more contextual scaffolding, and it has none.

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

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

The schema has one optional parameter (limit) with 0% description coverage. The tool description does not mention this parameter at all, adding no meaning beyond the schema's bare type definition. It fails to explain the purpose, format, or effect of 'limit'.

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 '获取控制台日志' is a direct translation of the tool name 'browser_get_console_logs'. It restates the name without adding any specificity about the resource, scope, or behavior, and does not distinguish it from sibling log-related tools like browser_get_request_logs or browser_get_response_logs.

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. There is no mention of context, prerequisites, or exclusions, leaving the agent without any information about which log retrieval tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description merely states the action without any detail about return format, scope, side effects (none expected for a getter), or whether it requires a browser context. This is a total lack of 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 extremely short (a single phrase), but this is under-specification rather than conciseness. The phrase '获取Cookie' does not earn its place because it merely restates the tool name. It lacks any explanatory structure or helpful detail, falling into the 'Process' trap where brevity replaces substance.

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

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

Given the tool's simplicity (no parameters), the description still fails to provide essential context. It does not state what cookies will be returned, whether they are for the current page or all cookies, or what the output format is (since there is no output schema). The description is completely inadequate for an agent to understand the tool's behavior without additional inference.

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

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

The tool has zero parameters, and the input schema is empty. Per the rubric, a baseline of 4 is appropriate since there are no parameter semantics to explain. The description does not need to add parameter details, though it could have used the space to explain what 'cookies' refers to.

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 '获取Cookie' translates directly to 'Get Cookie', which is essentially a restatement of the tool name 'browser_get_cookies'. It does not add any specificity about what cookies are retrieved (e.g., all cookies, current page, domain), nor does it distinguish from sibling tools. This is a tautology rather than a purposeful description.

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 about when to use this tool versus alternatives. It does not mention that it complements browser_set_cookies and browser_clear_cookies, nor does it explain prerequisites (e.g., needing an active page). The absence of any usage context leaves the agent without 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?

No annotations are provided, so the description carries the full burden. It only says 'start collecting' but doesn't disclose side effects, whether it clears previous coverage, what the return value is, or how it interacts with browser_stop_coverage. This is a significant gap.

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

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

The description is extremely short, but conciseness should not come at the expense of essential information. It is under-specified and fails to explain the tool's actual behavior or output, making it more of an underspecified placeholder than a useful 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 no output schema, no annotations, and a misleading description, the tool is incompletely specified. The description doesn't state what the tool returns, what side effects it has, or how it fits into the coverage lifecycle, so the agent cannot reliably invoke or interpret the result.

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 covers 100% of them trivially. The description adds no parameter semantics, but none are needed, so the baseline of 4 is appropriate.

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

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

The description '开始收集代码覆盖率' (start collecting code coverage) states an action but conflicts with the tool name 'get_coverage', which implies retrieval. It doesn't clarify whether this tool starts coverage collection or returns collected data, and it doesn't distinguish it from sibling tools like browser_stop_coverage.

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 doesn't mention prerequisites, expected sequence (e.g., start before stop), or relationships to sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without any details about prerequisites, error behavior, return format, or side effects, offering no additional transparency beyond the tool name.

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

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

The description is a single, highly concise phrase that directly states the tool's purpose. Every word earns its place, and there is no wasted text or repetition.

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

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

For a parameterless getter, the description adequately conveys the core function. It does not detail return values or edge cases, but the simplicity of the tool makes this less critical. Given no annotations or output schema, it is reasonably complete.

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

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

The tool takes zero parameters, so the input schema is trivially complete. The description does not need to explain parameter semantics, and the baseline of 4 is appropriate.

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

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

The description '获取当前URL' (Get current URL) uses a specific verb 'get' and a clear resource 'current URL', unambiguously distinguishing it from sibling tools that retrieve other page properties like title or HTML.

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 alternative guidance is provided. The purpose is clear enough that an agent can infer it is for retrieving the current URL, but there is no mention of when not to use it or comparison with similar getter tools.

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

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

With no annotations provided, the description bears full responsibility for behavioral disclosure. It only states the operation without explaining what frames are included, the output format, or any side effects. This is a significant gap for a tool that retrieves data.

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

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

The description is very brief (three words in Chinese), which is concise but arguably under-specified. It does not waste words, but it also fails to include any explanatory context that would help an agent understand the tool's exact function.

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

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

Given no output schema, the description should describe the return value and scope. It does neither, leaving the agent uncertain about what frames are returned and in what format. The description is inadequate for a tool that could have multiple interpretations.

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

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

The tool has zero parameters, so the baseline of 4 applies. The description adds no parameter information, but none is needed since there are no inputs to document.

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 '获取所有frame' (get all frames) states a clear action and resource, distinguishing it from sibling tools like browser_get_all_pages. However, it does not specify whether frames refers to iframes on the current page or all frames in the browser, leaving slight ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites, scope (current page vs entire browser), or any exclusions, leaving the agent to infer usage from the tool 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?

No annotations are present, so the description must carry the full behavioral disclosure burden. It only restates the purpose and does not mention return format, encoding, or side effects, offering minimal transparency for a read operation.

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

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

The description is a single concise phrase with no filler words. It is appropriately sized for the tool's simplicity and immediately conveys the core purpose.

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

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

With zero parameters and no output schema, the description is minimally viable but lacks return details (e.g., whether it returns full serialized HTML or just body content). Given the rich set of sibling tools, slightly more context would improve 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 tool has zero parameters, earning a baseline of 4. There is no schema coverage gap to compensate for, and the description adds no parameter-related meaning since none exist.

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 '获取页面HTML' clearly states the action (获取/get) and resource (页面HTML/page HTML). It distinguishes itself from sibling tools like browser_get_text or browser_get_title, which target different content types.

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

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

No guidance is provided on when to use this tool versus alternatives. Among many sibling getters (get_text, get_links, get_current_url), the description gives no context or exclusions, leaving the agent to infer intended use.

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

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

No annotations exist, so the description carries the full burden, but it provides no behavioral details. It does not disclose what happens if the element is not an input, whether the value is returned as a string, or error behavior when the selector matches nothing. This is minimal coverage for a tool with no annotation support.

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 phrase with no wasted words. It is appropriately sized for a simple tool, front-loaded with the essential purpose.

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

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

With no output schema, no annotations, and a single parameter lacking explanation, the description is incomplete. It does not cover return types, element compatibility, or error cases, which are critical for an agent to use the tool correctly in varied scenarios.

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

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

Schema description coverage is 0%, and the description adds nothing about the 'selector' parameter. It doesn't explain whether the selector is CSS, XPath, or some other format. The parameter name alone is insufficient for an agent to reliably construct a correct invocation.

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

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

The description '获取输入框值' translates to 'Get input field value', which clearly identifies the action (getting a value) and the resource (input element). It distinguishes itself from siblings like browser_get_text or browser_get_attribute by specifying 'input value', though it doesn't explicitly state it's for input/textarea/select elements only.

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

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

No usage guidance is provided. The description does not mention when to use this tool versus alternatives such as browser_get_text or browser_get_attribute, nor does it indicate prerequisites or context for use.

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

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

With no annotations supplied, the description must carry the full burden of behavioral disclosure. It only says 'get all links' without explaining what is included (e.g., hidden or dynamic links), how the result is structured, or whether any side effects occur. This is a significant gap for a tool with zero annotation coverage.

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

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

The description is extremely concise with no wasted words, but it borders on under-specification. It is a single phrase that lacks structure or detail, which is not ideal for a tool in a large sibling group.

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

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

Given the tool's simplicity (no params, no output schema), the description should still clarify what 'links' refer to and what the return value looks like. The current description leaves too much to interpretation, making it incomplete for an AI agent to use reliably.

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

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

The tool has zero parameters, so according to the baseline for 0-param tools, a score of 4 is appropriate. The description adds minimal extra meaning, but since there are no parameters to clarify, it does not need to go further.

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 all links) clearly states a specific action of retrieving links, which is distinct from most sibling tools. However, it does not specify the scope (e.g., current page) or the format of the links returned, leaving some ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives. Sibling tools like browser_get_by_text or browser_get_attribute are not referenced, and the description does not mention any 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?

With no annotations, the description must carry the burden of behavioral disclosure. It only says 'Get LocalStorage' and does not mention return format, error behavior (e.g., missing key), side effects, or any nuances. This is a significant gap for an agent.

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

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

The description is extremely short, but this is under-specification rather than genuine conciseness. It provides no useful information beyond the tool name, so it fails to earn its place as a meaningful 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?

For a simple tool with no annotations and no output schema, the description still needs to explain basic semantics. 'Get LocalStorage' leaves the agent guessing about the key parameter, return value, and behavior when the key is absent. It is grossly inadequate.

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

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

The input schema has a single 'key' parameter with no description, and the description does not explain what 'key' refers to or how it maps to LocalStorage entries. With schema description coverage at 0%, the description must compensate, but it does not.

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 '获取LocalStorage' directly translates to 'Get LocalStorage', which is essentially a restatement of the tool name. It does not clarify whether it retrieves a specific key or all entries, nor does it differentiate from sibling tools beyond the inherent 'get' semantics.

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_set_local_storage or browser_clear_local_storage. The name implies a read operation, but the description provides no context, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It does not explain what specific metrics are returned, whether a page must be open, potential side effects, or return format. This is a significant gap for a tool that queries browser internals.

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 phrase with no waste, but it is under-specified. It essentially restates the tool name in Chinese, lacking the detail needed to understand what 'performance metrics' entails. It is concise but not informative enough.

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, no annotations, and a vague description, the tool is not adequately explained. Users cannot infer what metrics are retrieved, how they are formatted, or when this tool should be used relative to browser_get_coverage or other getters. The description is incomplete for a tool that likely returns complex performance data.

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 baseline is 4. The description does not need to add parameter semantics because there are none to explain.

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 performance metrics) clearly states the verb (get/fetch) and resource (performance metrics). It is specific enough to distinguish from sibling tools like browser_get_coverage, though it lacks additional scope details.

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 are no mentions 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It merely says '获取请求日志' without addressing pagination, limits, ordering, whether logs are cleared, or what the output structure is. The description is essentially a restatement of the tool name.

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

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

The description is extremely short, which might be seen as concise, but it is under-specified. It lacks essential information about the tool's behavior and usage, making it closer to a tautology than a helpful, well-structured description.

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

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

The tool is a simple log retrieval operation, but the description is inadequate. It fails to explain what 'request logs' means, how the limit parameter works, whether output is returned, or any relevant details that would make the tool usable. The absence of an output schema and annotations makes this incompleteness critical.

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

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

The input schema has a single 'limit' parameter with 0% schema description coverage. The description does not mention 'limit' or explain its meaning, default value, or effect, providing no additional value beyond the bare schema.

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

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

The description '获取请求日志' translates to 'Get request logs', which clearly states the tool's verb and resource. However, it does not distinguish from sibling tools like browser_get_response_logs or browser_get_console_logs, as it lacks specificity about the log type or source.

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

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

There is no guidance on when to use this tool versus alternatives. The description provides no context, prerequisites, or examples, leaving the agent without criteria for selecting it over other logging tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not disclose whether logs are cleared after retrieval, whether the operation is read-only, how logs are ordered, or what the return payload looks like. The description offers zero behavioral context.

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

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

While the description is extremely short, it is under-specified rather than concise. The single phrase restates the tool name and provides no useful details, so it does not 'earn its place' in a meaningful way.

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 being simple (one parameter, no output schema), the description is critically incomplete. It lacks any explanation of behavior, parameter semantics, or relationship to other log-related tools. An agent cannot determine how to invoke it correctly or interpret results from this description alone.

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

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

The schema has one parameter 'limit' with no description, and schema description coverage is 0%. The description does not mention or explain the 'limit' parameter, nor does it compensate for the schema gap. The agent receives no semantic information about the parameter's meaning or effect.

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 '获取响应日志' is a direct Chinese translation of the tool name 'browser_get_response_logs', essentially restating the name without adding any new information about scope, behavior, or differentiation from sibling tools like browser_get_request_logs. It is tautological rather than explanatory.

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_get_request_logs or browser_get_console_logs. No context, preconditions, or exclusions 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?

There are no annotations, so the description must disclose behavioral traits. It only states the basic action, but does not mention what happens for missing elements, whether multiple matches are handled, what the return format is, or whether it waits for the element. This leaves significant behavioral ambiguity for an agent.

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

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

The description is extremely short and front-loaded, consisting of a single clear phrase that directly states the purpose. It wastes no words and is appropriately brief 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?

Given the lack of annotations, output schema, and parameter explanations, the description is not complete enough. It fails to cover usage trade-offs, edge-case behavior, or selector expectations, leaving the agent under-informed for reliable invocation in nuanced contexts.

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

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

Schema coverage is 0%, so the description must compensate for parameter meaning, but it does nothing of the sort. The only parameter 'selector' is left undescribed; the agent must infer its format (CSS, XPath, etc.) solely from the name, which is insufficient.

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

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

The description '获取元素文本' clearly states a specific action (get) and resource (element text), which distinguishes it from sibling getters like browser_get_html, browser_get_attribute, and browser_get_input_value. The verb+resource structure makes the tool's purpose immediately 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 like browser_get_by_text, browser_get_attribute, or browser_get_input_value. There are no exclusions, prerequisites, or context hints to help an agent choose correctly.

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 just the action phrase with no behavioral disclosure. It does not mention that the tool operates on the current page, what happens if no page is loaded, or the return format. Since no annotations are provided, the description carries the full burden and fails to provide any 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 short phrase with no structure, but it is concise. However, it is under-specified and provides little value beyond the tool name, so it does not earn a higher score for appropriate sizing and front-loading.

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?

Even for a simple getter, the description lacks essential context such as return value, current page assumption, and error behavior. Without an output schema or annotations, this is insufficient for an agent to use the tool confidently, making the description incomplete.

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

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

The input schema has zero parameters, so there is nothing to document. The baseline for zero-parameter tools is 4, and the description does not need to add parameter semantics because no parameters exist.

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 '获取页面标题' directly restates the tool name (browser_get_title) in Chinese, offering no additional specificity or differentiation from sibling getter tools. It is essentially a tautology, not a clear purpose statement that distinguishes the tool from others like browser_get_text or browser_get_current_url.

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 about when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusion conditions, leaving the agent without direction on when to select this tool over similar getters.

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

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

With no annotations provided, the description is solely responsible for disclosing behavior. It only states '获取浏览器版本' without mentioning the return format, potential errors, or any prerequisites, offering insufficient behavioral 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 entire description is a single short phrase, making it extremely concise and front-loaded with the core action. There is no redundant information.

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

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

The description is functional for a simple getter, but it does not specify the output type or format, and there is no output schema to supplement this. For a zero-parameter tool, this is a minor but noteworthy gap.

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

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

The input schema is an empty object with zero parameters, meaning there is nothing to explain. The baseline score of 4 applies because the description adds no parameter semantics, but none are needed.

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

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

The description '获取浏览器版本' clearly identifies the tool's purpose as retrieving the browser version. This specific verb+resource combination distinguishes it from all sibling tools, none of which target version retrieval.

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

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

The description provides no explicit guidance on when to use this tool or any exclusions. While the purpose implies use when needing the browser version, no contextual or alternative-specific information is given, resulting in minimal guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention that this is a read-only operation, what the return value contains (e.g., width and height), or any units. Critical information about the output is missing.

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

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

The description is extremely concise, consisting of a single short phrase with no wasted words. It is appropriately sized for such a simple operation, though it could benefit from a bit more detail.

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

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

Given no output schema and no description of the return value, the tool is incomplete. For a getter, it is essential to know the format and meaning of the result (e.g., an object with width/height). The description also lacks context about how it applies to the current page or browser viewport.

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 takes zero parameters, so the baseline is 4. The description does not need to explain parameter meaning, and the schema confirms no parameters exist. Nothing is lacking in this dimension.

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

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

The description '获取视口大小' (Get viewport size) clearly states the action (get) and resource (viewport size). It is specific and easily distinguishable from the sibling browser_set_viewport_size, though it does not explicitly mention the alternative.

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 state when to use this tool, when not to use it, or mention alternatives. The intended context is only implied by the verb and resource.

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

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

No annotations are provided, and the description only states the literal action. It does not disclose behavior when there is no previous page, whether the page state is preserved, or any error conditions.

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

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

The description is extremely short, consisting of a single phrase. It is concise but lacks substantive detail; however, for a simple navigation action, this size is acceptable.

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 minimal and does not address important context like what happens if there is no browsing history. For a browser control tool, more detail is expected to avoid misuse.

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

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

The tool has zero parameters, so the description's lack of parameter information is not a deficiency. The baseline for 0 parameters is 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 '返回上一页' translates to 'go back to previous page,' which directly restates the tool's name 'browser_go_back.' It provides no additional specificity beyond the name, making it a tautology.

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

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

The description gives no indication of when to use this tool instead of alternatives like browser_go_forward, browser_reload, or browser_goto. There is no mention of history navigation context.

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

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

With no annotations provided, the description carries full responsibility for behavior. It says only 'go to next page' and does not disclose what happens when there is no forward history, whether navigation is synchronous, how it interacts with browser back/forward stack, or any potential side effects. This is minimal even for a simple navigation action.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. The single phrase adds no value beyond the tool name and leaves out critical operational context. A concise description should be informative, not just a translation.

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

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

For a tool with no annotations, no output schema, and no parameters, the description still needs to convey the operation's meaning and nuances. It fails to mention history-based navigation, limitations, or related tools. The description is essentially a label and not a complete explanation of the tool's context.

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

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

The tool has zero parameters, so the baseline score is 4. There is nothing to explain about parameters; the description's lack of parameter information is not a deficiency because no parameters exist.

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 '前进到下一页' is a direct translation of the tool name 'browser_go_forward' (go to next page). It restates the name in another language without adding any clarifying detail, making it essentially a tautology. It does distinguish from go_back by implying forward navigation, but that inference comes entirely from the name, not from the description itself.

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_go_back, browser_goto, or browser_reload. No context, prerequisites, or example scenarios are provided. The description consists only of a phrase and gives 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?

There are no annotations to fall back on, so the description carries the full burden. It only says 'navigate to specified URL' without disclosing side effects such as loading the page in the current tab, changing history, or behavior on navigation failure. This is minimal but not contradictory.

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 with no filler or redundancy. It is appropriately front-loaded and gets to the point, though it is somewhat under-specified. This is conciseness without waste, though not richly informative.

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

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

Given the tool has 3 parameters and no annotations or output schema, the description is too sparse. It fails to explain the timeout and waitUntil behavior, what triggers a successful navigation, or any consequences. The description is barely more than the tool name.

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

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

Schema description coverage is 0%, and the description does not compensate. It relates only to the 'url' parameter (specified URL) and completely ignores 'timeout' and 'waitUntil' parameters, leaving their meaning and usage unexplained.

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 ('navigate') and the target ('specified URL'), which is a specific verb+resource combination. It distinguishes from navigation history tools like go_back/go_forward by indicating a direct URL is provided, though it does not explicitly call out those 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?

No guidance is provided on when to use this tool versus alternatives. The description merely states what it does, with no mention of when it is appropriate (e.g., for initial navigation vs. history traversal) or any exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. The description merely says 'grant permissions' without explaining side effects, whether the grant is persistent, what permissions are valid, or the role of the origin parameter.

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, but this is under-specification rather than conciseness. It consists of a single phrase that conveys no useful information beyond the tool name.

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

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

Given that there are no annotations, no output schema, and only a minimal schema, the description must provide more context. A single-word description is wholly inadequate for an agent to understand when and how to invoke this tool.

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

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

The schema has 0% description coverage, and the description does not explain the meaning of 'origin' or 'permissions'. It fails to clarify that origin is optional while permissions is required, and does not list accepted permission values.

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

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

The description '授予权限' is a direct translation of the tool name 'grant_permissions', making it a tautology. It provides no specific verb-object distinction or differentiation from sibling tools like browser_clear_permissions.

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, typical use cases, or that browser_clear_permissions is the inverse operation.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not mention that the tool handles browser dialogs (e.g., alert/confirm/prompt), what happens when promptText is provided, or any side effects. Essentially none of the behavior is disclosed.

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

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

The description is extremely short, but this is under-specification rather than conciseness. A single phrase that adds no information does not 'earn 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?

The tool has two parameters, no output schema, and no annotations. The description is insufficient to understand the tool's purpose, acceptable inputs, or behavior, which is a serious gap for any tool 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 0% and the description adds nothing about the parameters. The action enum (accept/dismiss) and promptText are entirely unexplained, leaving the agent to infer their purpose from names alone.

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

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

The description '处理对话框' merely restates the tool's name ('handle dialog') without specifying the action or resource context. It does not explain what handling a dialog involves (accept/dismiss), and fails to distinguish this tool from any other browser sibling.

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 gives no context about dialog types or conditions under which accept or dismiss should be chosen.

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

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

With no annotations, the description must disclose all behavioral aspects. It only says 'mouse hover' without explaining what happens: whether it moves to the element center, triggers hover effects, requires visibility, or what occurs if the selector matches nothing. No side effects or limitations are mentioned, leaving the agent entirely uninformed.

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 word, which is under-specification rather than conciseness. While it is short, it does not earn its place because it communicates no more than the tool name itself. It lacks the structural elements (usage, parameters, examples) needed to be minimally viable.

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 and no output schema, the description should at least explain what the parameter is and how the hover action is performed. This description provides none of that context, making it impossible for an agent to use the tool correctly without external knowledge. It is completely inadequate.

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 lists a single parameter 'selector' with no description, and the tool description provides zero explanation of what this selector should represent (CSS selector, XPath, etc.). With schema description coverage at 0%, the description fails to compensate by adding any meaning to 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 '鼠标悬停' (mouse hover) essentially restates the tool name without adding specificity. It fails to distinguish what this tool does differently from sibling tools like browser_mouse_move or browser_hover itself. The verb is clear but the resource and scope are undefined.

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

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

No guidance is given on when to use this tool versus alternatives such as browser_mouse_move or browser_click. There is no mention of prerequisites, typical use cases, or exclusions. The description provides no context to help an agent decide between hovering and 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to mention any side effects, permissions, what the tool modifies, or what happens when executed, leaving the agent completely in the dark.

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, but this is under-specification rather than conciseness. A single tautological phrase does not earn efficiency credit because it conveys no actionable information.

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

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

The tool has no annotations, no output schema, and only a cryptic parameter. The description contributes essentially nothing beyond restating the tool name, making the tool effectively undocumented and unusable without external knowledge.

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 single parameter 'time' is undocumented in the schema (0% coverage) and the description offers no explanation of its meaning, format, or allowed values. The agent has no basis to infer even basic 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 '安装时钟控制' is a direct translation of the tool name ('install clock control'), providing no additional functional clarity. It does not specify a clear verb+resource action or distinguish itself from sibling clock-related tools like browser_set_system_time, browser_pause_clock, or browser_resume_clock.

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, what prerequisites exist, or which alternatives might be more appropriate. The description is completely silent on 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to mention what the tool returns (e.g., boolean), whether it waits for the checkbox to exist, or any side effects. The phrase 'check state' is insufficient for an agent to understand the tool's behavior.

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

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

The description is extremely short (two characters in Chinese), which is under-specification rather than conciseness. It does not earn its place by adding any useful information beyond the tool name.

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

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

The tool is simple (one param, no output schema), but the description still fails to provide essential context such as return type or typical usage. It is incomplete even for a basic state-check tool.

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

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

The schema has one parameter 'selector' with no description, and the tool description does not explain what 'selector' means or how it should be formatted. With 0% schema coverage and no compensatory explanation in the description, the parameter semantics are completely unexplained.

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 '检查复选框状态' (check checkbox state) directly restates the tool name 'browser_is_checked' without adding specificity about what 'state' means (e.g., checked/unchecked). It provides a verb and resource but does not distinguish this tool from siblings like browser_is_visible or browser_is_enabled.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of how it relates to browser_check, browser_uncheck, or other state-query tools. The description implies a state check but provides 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?

There are no annotations provided, so the description must fully describe behavioral traits. It only restates 'check connection status' without adding any detail about side effects, return type, error conditions, or what 'connected' refers to. This is essentially a tautology of the tool name and provides 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, short sentence with no extraneous content. It is front-loaded and each word contributes to meaning. For a tool of this simplicity, the conciseness is ideal.

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 (no parameters, likely a simple boolean check), the description is minimally adequate. However, it does not explicitly state what the return value represents or what 'connection' means in this context, and there is no output schema. A slightly richer description would remove ambiguity, but the tool is simple enough that this is a minor gap.

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

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

The tool has zero parameters, and the schema has 100% coverage (trivially). The description needs to add no parameter-level explanation. According to the baseline for zero parameters, a score of 4 is appropriate.

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

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

The description '检查浏览器连接状态' clearly states the action (check) and the resource (browser connection status). It is distinct from siblings like browser_launch or browser_get_version by focusing on connectivity. However, it lacks explicit detail on what 'connection' means or what the result will be, which is only implied by the tool name.

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 any preconditions, related tools, or scenarios where this check is appropriate. Without any exclusions or context, the agent receives no help in deciding when to invoke this tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not explain what happens if the element does not exist, whether it returns a boolean, or any potential side effects. For a state-check tool, such details are important and are omitted.

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 concise and immediately communicates the core action. However, it is somewhat under-specified, though this is more relevant to other dimensions than to 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 simple nature, the description is minimal but incomplete. It does not mention the return value (likely boolean), error handling for missing elements, or any interaction with the page state. The absence of an output schema and annotations increases the need for a richer description, which is not 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?

The input schema has one parameter 'selector' with no description, and the schema description coverage is 0%. The description does not compensate for this, as it merely refers to 'element' without explaining how to identify it or what selector format is expected (e.g., CSS selector, XPath). The parameter semantics are essentially undocumented.

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 checks if an element is enabled, using a specific verb and resource. It distinguishes from sibling tools like browser_is_visible and browser_is_checked by focusing on the enabled state. However, it does not explicitly mention the return type or any scope limitations, keeping it slightly below a perfect score.

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

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

No guidance is provided on when to use this tool over alternatives. There is no mention of prerequisites, such as the element needing to exist, or when it is appropriate to check enabled state versus visibility or checked state. The description gives no context about typical use cases or exclusions.

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

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

No annotations are provided, so the description carries full responsibility. It does not disclose the return format (e.g., boolean), whether it waits for visibility, what happens if the element is not found, or any side effects. The behavioral traits are entirely opaque beyond the basic action.

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

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

The description is a single short sentence, highly concise and front-loaded. Every word earns its place, with 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?

Although this is a simple tool, the complete absence of behavioral details (return value, exceptions, waiting behavior) and lack of output schema make the description inadequate. The agent cannot fully predict the tool's behavior or interpret results.

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

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

Schema description coverage is 0% and the description does not elaborate on the 'selector' parameter. The agent is left with only the parameter name and type, with no explanation of what constitutes a valid selector or how it relates to visibility checking.

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 '检查元素可见性' (Check element visibility) uses a specific verb and resource, clearly indicating the tool checks element visibility. This distinguishes it from sibling tools like browser_is_enabled and browser_is_checked.

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 simply states the action without context, prerequisites, or exclusions, leaving the agent to infer usage.

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

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

With no annotations, the description must carry the full burden. '按下' implies a key-down event, but it does not state that the key is held down until a corresponding keyboard_up call, nor does it mention focus requirements or modifier key behavior. The minimal wording provides only vague behavioral disclosure.

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 phrase with no wasted words. It is front-loaded and appropriately sized for a tool with one parameter, but it is so minimal that conciseness comes at the expense of 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?

The tool has a simple schema and no output schema, but the description still needs to clarify the key format, the relationship with keyboard_up, and when to use it instead of browser_press. All of this is missing, making the description insufficient for reliable invocation.

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

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

The schema defines only 'key' as a required string, but neither the schema nor the description explains the expected format (e.g., 'Enter', 'a', or 'Control'). Schema description coverage is 0%, and the description adds no meaning to 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 '按下键盘按键' translates to 'Press keyboard key'. It uses a specific verb and resource, but does not explicitly distinguish the 'down' action from a full key press, especially given the sibling tool browser_press. The language mismatch (Chinese vs English tool name) may also reduce clarity for some agents.

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_keyboard_up, browser_press, or browser_keyboard_insert_text. There are no exclusions or context cues.

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

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

With no annotations, the description carries the full burden. It discloses one important behavioral trait (no keyboard events), which adds value beyond the name. However, it does not mention other effects such as whether existing text is replaced, whether focus is required, or what events (if any) are triggered.

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 with the core action and key differentiator. 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?

The tool is simple, but the description lacks usage context, return value, and details about its effect beyond 'insert'. Without annotations or an output schema, the agent may not know how to correctly invoke it (e.g., whether focus is needed, whether it appends or replaces). The differentiator is useful, but overall incomplete for a browser automation 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 0%, and the description does not add any meaning beyond the parameter name 'text' and its string type. The text to insert is obvious, but no extra semantics are provided (e.g., format, length limits, encoding).

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 (insert text) and adds a key differentiator: it does not trigger keyboard events. This distinguishes it from sibling tools like browser_type or browser_fill, though it could be more explicit about the target element (e.g., focused element).

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It mentions the 'no keyboard events' feature but does not state use cases, prerequisites, or when to prefer it over browser_type, browser_fill, or other input methods.

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

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

With no annotations provided, the description carries the full burden. It only paraphrases the tool name without disclosing any additional behavior, side effects, or requirements (e.g., whether a key must have been pressed first).

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 filler, earning every word. However, it is slightly terse and could be enriched with minimal usage hints 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?

The tool is simple, but the description lacks usage context, parameter semantics, and behavioral caveats. Given no annotations or output schema, it is incomplete for an agent to use confidently, especially with many sibling tools.

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

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

The schema has one required 'key' parameter with no description and 0% schema coverage. The tool description does not mention the parameter or explain valid values (e.g., keyboard codes vs characters), leaving the agent without guidance.

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 (release) and the resource (keyboard key). It is specific and distinguishes this tool from siblings like browser_keyboard_down, which performs the opposite action.

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, such as mentioning that it pairs with browser_keyboard_down or that it is for key combinations. There is no explicit context or alternative mention.

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

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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It only lists high-level features (device simulation, video recording, tracking) without explaining side effects, return values, browser instance lifecycle, or prerequisites. '启动' implies action but gives no insight into what actually happens or what the agent should expect.

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 front-loads the core action. Every word earns its place, and it avoids redundancy with the schema.

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

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

This is a complex tool with 7 optional parameters, a nested viewport object, and no output schema or annotations. A launch operation should clarify return values, whether a browser context is created, and how it relates to subsequent sibling tools. The terse description leaves too much unstated for an agent to safely and correctly invoke it.

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

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

Schema description coverage is 57%, leaving headless, viewport, and browserType undocumented. The description mentions device simulation, video recording, and tracking, which map to deviceName, recordVideo, and recordTrace, but these already have schema descriptions. It adds no meaning for the undocumented parameters and does not compensate for the coverage gap with any new info.

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

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

The description clearly states the action and resource: '启动浏览器' (launch browser). It also distinguishes itself from sibling tools by highlighting unique launch-time capabilities like device simulation, video recording, and tracking, making it unmistakable from operations on existing browser contexts.

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 that this is the entry point for browser interaction, but it does not explicitly state when to use it, whether it should be called before other browser_* tools, or mention any alternatives. The sibling list makes it obvious enough, but explicit guidance is missing.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it reveals nothing about how mocking works, whether it mutates state, persists, or affects other browser operations. There is zero behavioral context beyond the tool's name.

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

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

The description is extremely short, but this is under-specification rather than conciseness. Every word is wasted because it merely echoes the tool name without providing useful structure or content. There is no front-loading of key information.

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

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

Given the tool has two required parameters (one an object) and no output schema, the description provides no guidance on return values, side effects, or expected usage. The description is entirely inadequate for an agent to safely or effectively invoke this tool.

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

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

Schema description coverage is 0%, and the description does not mention urlPattern or response parameters. The fallback to schema is empty, so the agent cannot infer what values to provide or how they behave. The description adds no semantic 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 '模拟响应' is a direct translation of the tool name ('mock response'), providing no additional meaning. It does not state what the tool does, what resource it acts on, or how it differs from 83 browser sibling tools. This is a tautology.

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

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

The description offers no guidance on when to use this tool versus alternatives, no context for its typical use case, and no exclusions or prerequisites. An agent has no basis for selecting this tool over siblings like browser_intercept_requests or browser_wait_for_response.

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