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. It states 'activate' implies a mutation, but doesn't specify if this changes page state, requires permissions, has side effects, or what happens on failure. For a mutation tool with zero annotation coverage, this is a significant gap in 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, efficient sentence '激活指定的页面' that directly states the action. It's front-loaded with the core purpose, though it could be more informative. There's no wasted text, making it appropriately concise for its limited content.

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

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

Given the tool's complexity (a mutation action with no annotations and no output schema), the description is incomplete. It doesn't explain what 'activate' entails, the expected outcome, error conditions, or how it relates to sibling tools. For a tool that likely changes browser/page state, more context is needed to guide effective use.

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

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

Schema description coverage is 100%, with the parameter 'pageId' documented as '页面ID' (page ID). The description adds no additional meaning beyond this, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate as the schema handles parameter documentation adequately.

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

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

The description '激活指定的页面' (Activate the specified page) provides a basic verb+resource combination, indicating it performs an activation action on a page. However, it's vague about what 'activate' means operationally and doesn't differentiate from siblings like 'createPage' or 'browserNavigate', which also involve page manipulation. The purpose is understandable but lacks 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?

No guidance is provided on when to use this tool versus alternatives. With siblings like 'createPage', 'browserNavigate', and 'listPages', the description doesn't clarify if 'activate' is for switching focus, reloading, or another purpose, nor does it mention prerequisites or exclusions. This leaves usage context ambiguous.

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. '点击页面元素' only states the action but doesn't describe what happens after clicking (e.g., page navigation, element state change, error handling). It doesn't mention authentication needs, rate limits, or whether this is a read-only or mutating operation. The description is too minimal for a tool that performs interactive browser actions.

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 - a single Chinese phrase. While this may be too brief for adequate tool understanding, it's perfectly front-loaded with zero wasted words. Every character serves the core purpose statement, making it maximally efficient in terms of word economy.

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 this is a browser interaction tool with 3 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't explain what the tool returns (success/failure status, page state changes), doesn't mention error conditions, and provides minimal context for a tool that performs potentially complex browser automation. The agent would need to guess about the tool's behavior and outcomes.

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

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

Schema description coverage is 100%, so all parameters (pageId, ref, waitForTimeout) are documented in the schema. The description adds no additional parameter information beyond what's already in the structured schema. According to scoring rules, when schema coverage is high (>80%), the baseline score is 3 even without parameter details in the description.

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

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

The description '点击页面元素' (click page element) is a tautology that essentially restates the tool name 'browserClick' in Chinese. It doesn't specify what type of clicking occurs (single click, double click, right click) or what happens after the click. While it mentions the resource ('页面元素' - page element), it lacks the specificity needed to distinguish it from similar tools like browserPressKey or browserSelectOption.

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 doesn't mention prerequisites (e.g., needing an active page), exclusions, or comparison to sibling tools like browserPressKey (for keyboard interactions) or browserSelectOption (for dropdown selections). The agent must infer usage from context 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 provided, so the description carries the full burden of behavioral disclosure. It states the action (upload files) but lacks details on permissions needed, whether it's destructive (e.g., overwrites existing files), rate limits, error handling, or what happens after upload (e.g., page changes). For a mutation tool with zero annotation 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 a single, efficient sentence ('上传文件到指定元素') that directly states the tool's function without unnecessary words. It's front-loaded and appropriately sized for its purpose, though it could benefit from more context to improve completeness.

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

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

Given the tool has no annotations, no output schema, and involves mutation (uploading files), the description is incomplete. It doesn't cover behavioral aspects like side effects, return values, or error conditions. For a 4-parameter tool in a browser automation context, more detail is needed to ensure safe and correct usage.

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

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

Schema description coverage is 100%, so the schema already documents all parameters (pageId, paths, ref, waitForTimeout) with descriptions. The tool description adds no additional meaning beyond what's in the schema, such as explaining how 'ref' identifies the element or format of 'paths'. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description '上传文件到指定元素' (Upload files to specified element) states a clear verb+resource combination, indicating it uploads files to an element. However, it doesn't distinguish this tool from other browser interaction tools like 'browserClick' or 'browserType', which also target elements. The purpose is understandable but lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are no explicit instructions on prerequisites (e.g., needing an open page or specific element type), exclusions, or comparisons to other tools like 'downloadImage' or general file handling. Usage is implied by the action but not contextualized.

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 burden but offers minimal behavioral insight. '处理' (handle) implies a mutation action on browser dialogs, but it doesn't disclose critical traits: whether it requires specific dialog states, what happens on acceptance vs. dismissal, if it affects page navigation, or potential side effects like page reloads. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding its 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 concise with a single phrase '处理浏览器对话框', which is front-loaded and wastes no words. However, this brevity borders on under-specification rather than optimal conciseness, as it omits necessary details for clarity. It earns a 4 for being compact but loses points for not including even minimal operational 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's complexity (handling browser dialogs with mutation), lack of annotations, and no output schema, the description is incomplete. It doesn't cover return values, error conditions (e.g., what if no dialog exists), or integration with sibling tools like waitForSelector for dialog detection. For a 4-parameter tool with behavioral implications, this minimal description fails to provide adequate context for safe and effective use.

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

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

Schema description coverage is 100%, with clear parameter descriptions in the schema (e.g., 'accept' as boolean for dialog acceptance, 'promptText' for response text). The description adds no additional meaning beyond the schema, such as explaining parameter interactions (e.g., 'promptText' is only relevant for prompt dialogs) or default behaviors. Given high schema coverage, the baseline score of 3 is appropriate as the schema adequately documents 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 '处理浏览器对话框' (Handle browser dialog) is a tautology that essentially restates the tool name 'browserHandleDialog' in Chinese. It doesn't specify what type of browser dialog (alert, confirm, prompt) or what 'handle' means (accept, dismiss, respond). While it distinguishes from siblings like browserClick or browserType by focusing on dialogs, the purpose remains vague without clarifying the specific 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?

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an open page with a dialog), exclusions (e.g., not for non-dialog interactions), or related tools like browserPressKey for keyboard-based dialog handling. The description alone offers no context for appropriate usage scenarios.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but offers minimal information. It states the action (hover) but doesn't describe what happens after hovering (e.g., whether it triggers UI changes, waits for effects, or captures snapshots), error conditions, or performance implications. The input schema's 'waitForTimeout' parameter suggests timing behavior, but the description doesn't explain this. For a browser interaction tool with zero annotation coverage, this is inadequate.

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—a single Chinese phrase—with zero wasted words. It's front-loaded and to the point, though this brevity comes at the cost of completeness. Every sentence (in this case, the single phrase) earns its place by directly stating the action, making it structurally efficient despite informational gaps.

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

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

Given the complexity of a browser interaction tool with 3 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain the tool's behavior, return values (e.g., whether it provides feedback or snapshots), or how it fits into workflows with sibling tools. The lack of output schema means the description should ideally hint at results, but it doesn't. This is inadequate for guiding an AI agent effectively.

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

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

The schema description coverage is 100%, with all parameters documented in the schema itself (pageId, ref, waitForTimeout). The description adds no additional meaning beyond what the schema provides—it doesn't clarify parameter relationships, usage examples, or edge cases. According to the scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no parameter info in the description, which applies here.

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

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

The description '悬停在页面元素上' (hover over a page element) is a tautology that essentially restates the tool name 'browserHover' in Chinese. It doesn't specify what resource is being hovered over (browser page element) or distinguish this from sibling tools like 'browserClick' or 'browserPressKey' that also interact with page elements. The purpose is clear at a basic level but lacks specificity and differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'browserClick' for clicking or 'waitForSelector' for waiting on elements, nor does it specify use cases like triggering hover effects, tooltips, or dropdown menus. There's no indication of prerequisites, timing considerations, or when this tool would be preferred over other interaction 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only states the navigation action without mentioning what happens after navigation (e.g., whether it waits for page load, returns a snapshot, or handles errors). It doesn't address permissions, rate limits, or side effects like changing browser state. For a navigation tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is extremely concise - a single phrase that directly states the tool's purpose. There's zero wasted language or unnecessary elaboration. It's front-loaded with the core action and immediately communicates what the tool does without any preamble or secondary 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 complexity of browser navigation (which involves state changes, potential errors, and timing considerations), the description is insufficient. With no annotations, no output schema, and a minimal description that only states the basic action, important context is missing. The agent doesn't know what the tool returns, how it handles navigation failures, or what the waitForTimeout parameter actually affects in practice.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (pageId, url, waitForTimeout) with their descriptions. The tool description adds no additional parameter information beyond what's in the schema. According to the scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the action ('导航到' - navigate to) and the target resource ('指定URL' - specified URL), making the purpose immediately understandable. It distinguishes itself from siblings like browserNavigateBack and browserNavigateForward by specifying forward navigation to a URL. However, it doesn't explicitly mention that this operates within a browser context, which is implied but could be more specific.

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 (like needing an active page), when not to use it, or how it differs from similar tools like createPage (which might also navigate). Without any usage context, the agent must infer everything from the tool name and parameters 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 provided, so the description carries the full burden of behavioral disclosure. It states the action but lacks details on effects (e.g., whether it waits for page load, handles errors if no history exists, or returns a result). For a navigation tool with zero annotation coverage, this is a significant gap in transparency about how it behaves.

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, efficient sentence ('返回到上一页') that directly states the tool's purpose with zero waste. It is appropriately sized and front-loaded, making it easy to parse quickly without unnecessary elaboration.

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

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

Given the tool's complexity (navigation with parameters) and lack of annotations and output schema, the description is incomplete. It doesn't cover behavioral aspects like error handling, return values, or interaction with page state, leaving gaps for an agent to understand how to use it effectively in 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 100%, so the schema fully documents both parameters (pageId and waitForTimeout). The description adds no additional meaning beyond what the schema provides, such as explaining why pageId is required or how waitForTimeout interacts with navigation. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description '返回到上一页' (Return to the previous page) clearly states the action (return/navigate back) and resource (page), making the purpose immediately understandable. It distinguishes from siblings like browserNavigate (forward navigation) and browserNavigateForward (explicit forward), though it doesn't explicitly mention the browser context which is 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?

No explicit guidance on when to use this tool versus alternatives is provided. The description doesn't mention prerequisites (e.g., having a page to navigate back from), when not to use it (e.g., if no history exists), or compare it to siblings like browserNavigate (for specific URLs) or browserNavigateForward. Usage is implied but not articulated.

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 burden but only states the action without disclosing behavioral traits like whether it waits for page load, handles errors, or returns any output. It mentions waiting for a snapshot via the 'waitForTimeout' parameter in the schema, but this isn't explained in the description itself, leaving gaps in 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, efficient phrase ('前进到下一页') that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, with zero waste.

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 (a navigation action with parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what happens after navigation, potential side effects, or how it integrates with other browser tools, leaving significant gaps for an AI 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 input schema has 100% description coverage, so the description adds no additional meaning beyond what the schema provides. The baseline score of 3 is appropriate as the schema adequately documents the parameters, but the description doesn't compensate or enhance understanding.

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

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

The description '前进到下一页' (Navigate forward to the next page) states the basic action but lacks specificity about what resource it operates on (a browser page) and how it differs from siblings like 'browserNavigateBack'. It's clear but doesn't distinguish from 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 like 'browserNavigate' or 'browserNavigateBack', nor any context about prerequisites (e.g., needing a page with forward navigation available). The description alone implies usage but offers no explicit instructions.

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 description only states the action ('press keyboard key') without mentioning any behavioral traits such as what happens after pressing (e.g., page navigation, form submission), error conditions, or performance implications. It lacks context about browser state changes or interaction effects.

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

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

The description is extremely concise with just three Chinese characters ('按键盘按键'), which translates to 'Press keyboard key'. It's front-loaded with zero wasted words, making it easy to parse quickly. Every character serves the core purpose without redundancy.

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

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

Given the tool's complexity (browser automation with 4 parameters) and lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool returns, how it interacts with browser state, or potential side effects. For a tool that performs actions in a browser environment, more context about behavior and outcomes is needed.

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

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

Schema description coverage is 100%, so the schema already documents all 4 parameters thoroughly. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't explain parameter relationships or usage examples). With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but doesn't detract either.

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

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

The description '按键盘按键' (Press keyboard key) is a tautology that essentially restates the tool name 'browserPressKey' in Chinese. It doesn't specify what resource is being acted upon (a browser page) or distinguish this from sibling tools like 'browserType' (which also involves keyboard input). The purpose is stated but lacks specificity and differentiation.

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

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

No guidance is provided about when to use this tool versus alternatives. For example, it doesn't explain when to use 'browserPressKey' versus 'browserType' (which types text) or other browser interaction tools. The description offers no context about appropriate 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 the full burden of behavioral disclosure. While '选择选项' implies a UI interaction, the description doesn't mention what happens after selection (e.g., page changes, validation), error conditions, or performance characteristics like timeouts beyond what's in the schema. This leaves significant gaps 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 concise - a single phrase that directly states the tool's purpose with zero wasted words. It's appropriately sized for what it communicates, though it could benefit from additional 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?

For a UI interaction tool with 4 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what happens after selection, what the tool returns, error conditions, or how it differs from similar sibling tools. The 100% schema coverage helps with parameters but doesn't compensate for missing behavioral 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 100%, so the schema already documents all parameters thoroughly. The description adds no additional meaning about parameters beyond what the schema provides - it doesn't explain how 'values' should match dropdown options or provide examples of 'ref' XPath patterns.

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 ('选择选项' - select options) and the target ('下拉框' - dropdown), which is a specific verb+resource combination. However, it doesn't distinguish this tool from sibling tools like 'browserClick' or 'browserPressKey' that might also interact with UI elements, so it doesn't reach the highest clarity level.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'browserClick' and 'browserType' available, there's no indication of when dropdown selection is appropriate versus other interaction methods, nor any mention of 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 the full burden of behavioral disclosure. It mentions the action ('输入文本' - input text) but doesn't describe what happens after input (e.g., whether it triggers events, waits for page updates, or handles errors). It also doesn't cover permissions, rate limits, or side effects like page navigation after submission. This leaves significant gaps 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 a single, efficient sentence in Chinese ('在页面元素中输入文本'), which is appropriately sized and front-loaded. There's no wasted text, though it could benefit from slightly more detail to improve clarity without losing conciseness.

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

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

Given the complexity of a browser automation tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain the return value (e.g., success/failure status), error conditions, or how it interacts with other tools like waitForSelector. For a mutation tool in a rich sibling set, this lacks necessary context.

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

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

The schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description adds no additional meaning beyond what the schema provides (e.g., it doesn't explain how 'ref' relates to XPath or what 'slowly' entails in practice). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description '在页面元素中输入文本' (Input text into a page element) states a clear verb ('输入' - input) and resource ('页面元素' - page element), but it's vague about what distinguishes this tool from siblings like browserPressKey or browserSelectOption. It doesn't specify that this is for typing text into input fields, which would help differentiate it from other text-related actions.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose browserType over browserPressKey (for key presses) or browserSelectOption (for dropdowns), nor does it specify prerequisites like needing an active page or element reference. Usage is implied but not explicitly stated.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions 'scrolling, waiting and auto-trimming' which describes some behavior, it doesn't cover important aspects like: what format the snapshot returns (image? PDF? HTML?), whether this is a read-only operation, potential performance implications, or error conditions. For a tool with 7 parameters and no annotation coverage, this is 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 description is extremely concise - a single Chinese sentence that efficiently communicates the core functionality. Every word earns its place: 'capture webpage complete snapshot' establishes purpose, 'support scrolling, waiting and auto-trimming' highlights key features. No wasted words or 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?

Given the tool's complexity (7 parameters, no output schema, no annotations), the description is insufficiently complete. It doesn't explain what 'snapshot' means in terms of output format, doesn't mention whether this requires an active browser page (context from sibling tools suggests it might), and provides no guidance on error handling or performance considerations. For a tool that likely produces visual/structured output, the lack of output information is a significant gap.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds minimal value beyond the schema - it mentions 'scrolling, waiting and auto-trimming' which maps to scrolls, wait, and trim parameters, but doesn't provide additional context about how these interact or best practices. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose as 'capture webpage snapshot' with specific capabilities (scrolling, waiting, auto-trimming). It distinguishes itself from siblings like getPageSnapshot and getScreenshot by emphasizing 'complete snapshot' with scrolling functionality. However, it doesn't explicitly differentiate from getPDFSnapshot which might also capture full pages.

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

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

The description implies usage context through 'complete snapshot, support scrolling, waiting and auto-trimming' which suggests this is for capturing entire pages that require scrolling. However, it doesn't provide explicit guidance on when to use this versus alternatives like getPageSnapshot (which might be simpler) or getPDFSnapshot (which might produce different output formats). No explicit exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('关闭' - close) but doesn't clarify what 'close' entails (e.g., whether it destroys page state, requires confirmation, or affects browser sessions). It also omits details like error handling, side effects, or performance implications. For a mutation tool with zero annotation 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 a single, efficient sentence ('关闭所有管理的页面') that directly states the tool's purpose without unnecessary words. It's front-loaded and wastes no space, making it easy to parse quickly.

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

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

Given the tool's complexity (a mutation operation closing multiple pages), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'managed' means, what happens after closing (e.g., return values, errors), or how it interacts with sibling tools. For a potentially destructive action, more context is needed to ensure safe use.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate. Baseline 4 applies as it doesn't compensate for missing info but aligns with the schema's completeness.

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

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

The description '关闭所有管理的页面' (Close all managed pages) clearly states the action (close) and target (all managed pages). It distinguishes from sibling tools like 'closePage' (singular) and 'closePageByIndex' (specific index), though it doesn't explicitly mention these alternatives. The purpose is specific but could be more precise about what 'managed' means.

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 'closePage', 'closePagesWithoutId', or 'listPages'. It doesn't specify prerequisites (e.g., whether pages must be open), exclusions, or typical scenarios. Without such context, an agent might misuse it when a more targeted 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 full burden. It states the action ('关闭') but doesn't disclose behavioral traits such as whether this is destructive (likely yes, as closing a page typically removes it), what happens if the page doesn't exist, or if there are side effects (e.g., affecting other pages or browser state). This leaves significant gaps 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 a single, efficient sentence ('关闭指定的页面') that directly states the tool's purpose without any wasted words. It's front-loaded and appropriately sized for a simple tool, making it easy to parse quickly.

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

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

Given the complexity (a mutation tool with no annotations and no output schema), the description is incomplete. It lacks information on behavioral traits (e.g., destructiveness, error handling), usage context versus siblings, and output expectations. For a tool that likely modifies browser state, this leaves the agent with insufficient guidance to use it correctly.

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

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

The schema description coverage is 100%, with the parameter 'pageId' documented as '页面ID' (page ID). The description adds no additional meaning beyond what the schema provides, such as format examples or context about where to obtain the ID. With high schema coverage, the baseline is 3, and the description doesn't compensate with extra insights.

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 ('关闭' meaning 'close') and the resource ('指定的页面' meaning 'specified page'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'closeAllPages' or 'closePageByIndex', which would require mentioning that this tool closes a single page by ID specifically.

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 'closeAllPages', 'closePageByIndex', or 'closePagesWithoutId'. The description only states what it does, not when it's appropriate or what prerequisites might exist (e.g., needing an open page with the specified ID).

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

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

No annotations are provided, so the description carries full burden. It states the action (close page) but lacks details on behavioral traits: e.g., whether this destroys page content, requires specific permissions, has side effects, or returns any output. For a mutation tool with zero annotation coverage, this is a significant gap in 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, efficient sentence with zero waste—it directly states the tool's function. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

Given the complexity (a mutation tool closing pages), lack of annotations, no output schema, and incomplete behavioral disclosure, the description is inadequate. It doesn't explain what 'close' entails, potential errors, or how it interacts with sibling tools, leaving critical gaps for an AI agent.

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

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

Schema description coverage is 100%, with the parameter 'index' documented as '页面索引' (page index). The description adds no additional meaning beyond the schema, such as index format or range. Baseline is 3 since the schema does the heavy lifting, but no extra value is provided.

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

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

The description '通过索引关闭页面' (close page by index) states the verb (close) and resource (page) with a method (by index), which is clear. However, it doesn't distinguish from sibling tools like 'closePage' or 'closeAllPages'—it's vague about how this differs from those alternatives, leaving the purpose somewhat ambiguous in context.

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

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

There is no guidance on when to use this tool versus alternatives such as 'closePage' or 'closeAllPages'. The description implies usage by index but doesn't specify scenarios, prerequisites, or exclusions, offering minimal context for selection among siblings.

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

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

No annotations are provided, so the description carries the full burden. It states the action (close) but does not disclose behavioral traits such as whether this is destructive (likely yes, as it closes pages), what 'unmanaged' means, if there are permissions or side effects, or what happens after execution (e.g., confirmation, error handling). This is a significant gap for a mutation 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 a single, efficient sentence in Chinese ('关闭所有未被管理的页面') that directly states the tool's purpose with zero waste. It is appropriately sized and front-loaded, making it easy to understand quickly.

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

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

Given the complexity (a mutation tool that closes pages), no annotations, no output schema, and the description's lack of behavioral details (e.g., what 'unmanaged' means, effects, or return values), the description is incomplete. It should provide more context to guide safe and correct usage, especially since it involves a potentially destructive action.

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

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

There are 0 parameters, and schema description coverage is 100%, so no parameter information is needed. The description does not add parameter semantics, but with no parameters, the baseline is 4 as it adequately describes the tool's purpose without parameter details.

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

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

The description '关闭所有未被管理的页面' (Close all unmanaged pages) clearly states the action (close) and target (unmanaged pages). It distinguishes from siblings like 'closeAllPages' (closes all pages) and 'closePage' (closes a specific page) by specifying 'unmanaged' pages, though 'unmanaged' is not explicitly defined. It's not a tautology of the name 'closePagesWithoutId'.

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

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

The description implies usage when you want to close pages that are 'unmanaged', but it does not explicitly state when to use this tool versus alternatives like 'closeAllPages' or 'closePage'. The context is clear (closing unmanaged pages), but no exclusions or specific scenarios 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. '创建新的浏览器页面' implies a write operation that creates a new page, but it doesn't disclose behavioral traits like: what happens after creation (does it become active?), whether it requires specific permissions, if there are rate limits, or what the return value is (since no output schema exists). The description is too minimal 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 a single, efficient sentence ('创建新的浏览器页面') that directly states the purpose with zero waste. It's appropriately sized and front-loaded, though its brevity contributes to gaps in other dimensions.

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

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

Given the complexity (a mutation tool with 4 parameters, no annotations, and no output schema), the description is incomplete. It doesn't explain what the tool returns, behavioral implications, or usage context. For a tool that creates browser pages—potentially involving navigation and timing—more detail is needed to guide an AI agent effectively.

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

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

Schema description coverage is 100%, with all parameters documented in the schema (name, description, url, waitForTimeout). The description adds no parameter-specific information beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting.

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

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

The description '创建新的浏览器页面' (Create a new browser page) clearly states the verb ('创建' - create) and resource ('浏览器页面' - browser page). It distinguishes from siblings like 'activatePage' (activates existing page) or 'listPages' (lists pages), but doesn't explicitly mention how it differs from other creation-related tools since none exist in the sibling list.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether a browser context must be active), when not to use it, or how it relates to sibling tools like 'browserNavigate' (which navigates existing pages) or 'listPages' (which lists existing 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?

No annotations are provided, so the description carries full burden. It states the tool downloads to a temporary directory and returns a local file path, which is useful behavioral context. However, it lacks details on error handling (e.g., invalid URLs, network failures), file format support, or whether the file persists beyond the session. For a tool with no annotations, this leaves significant gaps in understanding its 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 concise—a single sentence in Chinese that directly states the tool's purpose and output. It's front-loaded with the core action and has no unnecessary words, making it efficient and easy to parse.

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

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

Given no annotations, no output schema, and a single parameter with full schema coverage, the description is minimal. It covers the basic purpose and output but lacks context on error cases, file management (e.g., cleanup), or integration with sibling tools. For a tool that interacts with external resources and local files, more completeness is needed to guide safe and effective use.

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

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

Schema description coverage is 100%, with the parameter 'url' clearly documented in the schema as '图片URL'. The description doesn't add any parameter-specific information beyond what the schema provides, such as URL format requirements or supported protocols. With high schema coverage, the baseline score of 3 is appropriate as the schema handles the parameter documentation adequately.

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

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

The description clearly states the action ('下载图片到本地临时目录') and the resource ('图片'), specifying it downloads an image to a local temporary directory. It distinguishes from siblings like 'getScreenshot' or 'captureSnapshot' which capture browser content rather than download external images. However, it doesn't explicitly mention the input parameter 'url' in the description text.

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 'getScreenshot' (which captures browser content) or other file-related tools. It doesn't mention prerequisites, limitations, or typical scenarios for downloading images versus capturing them from the browser.

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 burden for behavioral disclosure. It mentions the tool retrieves outerHTML for debugging purposes, but doesn't describe what happens if the element isn't found, whether this requires an active page session, what permissions are needed, or what the return format looks like. For a tool that interacts with browser elements, this leaves significant behavioral gaps.

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

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

The description is extremely concise and front-loaded with the core purpose in the first clause. Every word earns its place: it states what the tool does, how it works (via XP reference), and the primary use case. No wasted words or 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?

Given this is a browser interaction tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what happens on success/failure, what format the HTML is returned in, whether the page needs to be loaded first, or how this differs from similar sibling tools. The debugging context is helpful but doesn't compensate for missing behavioral 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 100%, with both parameters (pageId and ref) clearly documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema descriptions ('页面ID' and '元素的xp引用值'). This meets the baseline for high schema coverage where the description doesn't need to compensate.

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

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

The description clearly states the tool's purpose: '通过xp引用获取元素的outerHTML结构' (get element's outerHTML structure via XP reference). It specifies both the action (获取/获取) and resource (元素outerHTML结构), though it doesn't explicitly differentiate from sibling tools like getPageSnapshot or getScreenshot that also retrieve content. The debugging context ('用于调试选择器') adds useful 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 minimal usage guidance. While it mentions the tool is '用于调试选择器' (for debugging selectors), it doesn't specify when to use this tool versus alternatives like getPageSnapshot (which captures full page) or waitForSelector (which waits for elements). No explicit when-not-to-use or prerequisite information is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While it mentions the tool returns a '语义化简化快照' (semantic simplified snapshot) with '清晰的缩进结构' (clear indented structure), it doesn't explain what 'semantic simplification' means, whether this is a read-only operation, what permissions might be needed, or how the output is structured. For a tool with no annotation coverage, this leaves significant behavioral questions unanswered.

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

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

The description is very concise - just one sentence in Chinese. It's front-loaded with the core purpose. While efficient, it might be too brief given the complexity of what 'semantic simplified snapshot' implies and the lack of other documentation.

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

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

Given that this is a tool with no annotations, no output schema, and a potentially complex operation (semantic simplification of page content), the description is insufficient. It doesn't explain what 'semantic simplification' entails, what format the output takes, or how this differs from other snapshot tools. The description leaves too many questions unanswered for effective tool selection and use.

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

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

The description provides no information about parameters. However, with 100% schema description coverage (the single parameter 'pageId' has a description in the schema), the baseline score is 3. The description doesn't add any value beyond what's already documented in the input schema.

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

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

The description clearly states the tool's purpose: '获取页面的语义化简化快照' (get a semantic simplified snapshot of a page) and '返回清晰的缩进结构' (return a clear indented structure). It specifies the verb (获取/get) and resource (页面/page), but doesn't explicitly differentiate from sibling tools like 'captureSnapshot' or 'getPDFSnapshot' which might serve similar purposes.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'captureSnapshot', 'getPDFSnapshot', and 'getScreenshot' that might produce different types of page snapshots, there's no indication of what makes this tool unique or when it should be preferred over those options.

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

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

No annotations are provided, so the description carries full burden. It states the tool generates PDFs but doesn't disclose behavioral traits like whether it's a read-only operation, if it requires specific page states, what happens on failure, or any performance/rate limit considerations. The description is minimal and leaves critical behavior undefined.

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, efficient sentence in Chinese that directly states the tool's purpose. It's appropriately concise without unnecessary words, though it could be more informative given the tool's complexity.

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 a tool that performs a non-trivial PDF generation operation, the description is incomplete. It doesn't explain what the output contains, error conditions, or how it interacts with page state. For a tool with 4 parameters and significant functionality, this minimal description leaves too much undefined.

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

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

Schema description coverage is 100%, so the schema fully documents all 4 parameters. The description adds no parameter semantics beyond what's in the schema (e.g., it doesn't explain format options beyond 'A4' or clarify pageId requirements). Baseline 3 is appropriate since the schema handles parameter documentation adequately.

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

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

The description '获取页面的PDF快照' (Get PDF snapshot of a page) states the basic action and resource (page), but it's vague about scope and doesn't distinguish from siblings like 'getPageSnapshot' or 'captureSnapshot'. It specifies PDF output but lacks detail about what constitutes a 'snapshot' versus other capture tools.

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

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

No guidance on when to use this tool versus alternatives like 'getPageSnapshot' or 'getScreenshot'. The description implies it's for PDF generation from pages, but doesn't mention prerequisites, exclusions, or specific scenarios where it's preferred over other capture 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 of behavioral disclosure. It mentions saving to a temporary directory and returning a file path, which adds some context about output behavior. However, it doesn't cover critical aspects like whether this requires an active browser session, potential side effects (e.g., page loading), error handling, or performance implications (e.g., large page sizes).

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, efficient sentence that front-loads the core action and outcome. Every word earns its place with no redundancy or unnecessary details, making it highly concise and well-structured for quick 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?

Given the complexity (6 parameters, nested objects) and lack of annotations or output schema, the description is minimally adequate. It covers the basic action and result but misses details like error cases, file format specifics, or dependencies on other tools (e.g., needing 'createPage' first). For a tool with no annotations, it should provide more behavioral context to be fully complete.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain interactions between 'clip', 'element', and 'fullPage'). Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('获取页面截图并保存到临时目录') and the outcome ('返回文件路径'), making the purpose understandable. It specifies the resource (page screenshot) and the result (file path). However, it doesn't explicitly differentiate from sibling tools like 'captureSnapshot' or 'getPageSnapshot', which may have overlapping functionality.

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 'captureSnapshot' or 'getPageSnapshot'. It lacks context about prerequisites (e.g., needing an active page) or exclusions (e.g., not for PDFs). Usage is implied through the action but without explicit comparison to siblings.

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

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

No annotations are provided, so the description carries the full burden. It states the tool lists pages with title and URL, but doesn't disclose behavioral traits like whether it requires authentication, how it handles pagination or large result sets, or what 'managed pages' means (e.g., scope, permissions). For a listing tool with zero annotation 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 a single, efficient sentence in Chinese that directly states the tool's function. It's front-loaded with the core action and includes essential details (title and URL) without unnecessary elaboration. Every word earns its place.

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

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

Given the context: no annotations, no output schema, and 0 parameters, the description is minimal. It explains what the tool does but lacks completeness for a listing operation—it doesn't cover return format, error handling, or how 'managed pages' are defined. With no structured data to rely on, the description should provide more context.

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

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

The input schema has 0 parameters with 100% coverage, so no parameters need documentation. The description doesn't add param info, but that's fine since there are none. Baseline is 4 for 0 parameters, as the description doesn't need to compensate for any gaps.

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

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

The description clearly states the tool's purpose: '列出所有管理的页面（包含标题和URL）' translates to 'List all managed pages (including title and URL)'. It specifies the verb ('list'), resource ('managed pages'), and what information is included ('title and URL'). However, it doesn't explicitly distinguish it from sibling 'listPagesWithoutId', which is a similar listing tool.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to use it over 'listPagesWithoutId' or other page-related tools like 'createPage' or 'closeAllPages'. There's no context about 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 are provided, so the description carries full burden. It states it lists pages but doesn't disclose behavioral traits like whether this is a read-only operation, what format the output returns, potential performance considerations, or how 'unmanaged' is defined. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence in Chinese that directly states the tool's purpose with zero wasted words. It's appropriately sized and front-loaded, making it easy to understand immediately.

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

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

Given the tool has no parameters (simplifying context) but lacks annotations and an output schema, the description is minimally adequate. It states what the tool does but doesn't address output format, error conditions, or what constitutes 'unmanaged' pages. For a listing tool with no structured behavioral data, it should provide more context about 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?

The tool has 0 parameters with 100% schema description coverage. The description appropriately doesn't discuss parameters since none exist. It earns a 4 because it focuses on the tool's purpose without unnecessary parameter discussion, though not a 5 as it could briefly note the lack of parameters for clarity.

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 ('列出所有' = list all) and resource ('未被管理的页面' = unmanaged pages), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from its sibling 'listPages' (which presumably lists all pages including managed ones), so it falls short of a perfect 5.

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

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

The description implies usage context by specifying '未被管理的' (unmanaged), suggesting this tool should be used when you need pages that aren't managed. However, it doesn't provide explicit guidance on when to use this versus 'listPages' or other page-related tools, nor does it mention 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 are provided, so the description carries the full burden of behavioral disclosure. It states the action but lacks details on side effects (e.g., whether it triggers page reloads), error conditions (e.g., if the selector is invalid), or performance implications (e.g., timeouts). This leaves gaps in understanding how the tool behaves in practice.

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

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

The description is a single, concise sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core action and target, making it efficient and easy to parse. Every part of the sentence contributes essential information.

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

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

Given the complexity of a browser interaction tool with 3 parameters and no annotations or output schema, the description is incomplete. It doesn't cover behavioral aspects like what happens after scrolling (e.g., does it return a snapshot?), error handling, or integration with sibling tools. This leaves significant gaps for an agent to understand the tool's full context.

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

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

The schema description coverage is 100%, so the input schema already documents all parameters thoroughly. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't explain why 'selector' is optional or how 'waitForTimeout' affects the operation). Baseline 3 is appropriate as the schema handles parameter documentation adequately.

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

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

The description clearly states the action ('滚动到' meaning 'scroll to') and the target ('页面或元素底部' meaning 'page or element bottom'), which is specific and unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'scrollToTop' or 'waitForSelector', which might have overlapping use cases for element interaction.

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 scenarios where scrolling is necessary (e.g., loading dynamic content) or when other tools like 'waitForSelector' might be more appropriate. Without such context, the agent must 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 provided, so the description carries the full burden of behavioral disclosure. It mentions scrolling but does not cover aspects like whether this action is read-only, if it requires specific permissions, potential side effects (e.g., page reload), or error handling. The description is minimal and lacks behavioral context 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, efficient sentence in Chinese that directly states the tool's purpose without any unnecessary words. It is front-loaded and appropriately sized for the tool's complexity, making it highly concise and well-structured.

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

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

Given no annotations, no output schema, and a tool with 3 parameters (one required), the description is incomplete. It lacks details on behavioral traits, return values, error conditions, or how it integrates with sibling tools. For a browser interaction tool, more context is needed to ensure safe and effective use by an AI agent.

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

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

Schema description coverage is 100%, so the input schema already documents all parameters well. The description does not add any additional meaning or context beyond what the schema provides, such as explaining parameter interactions or usage nuances. With high schema coverage, the baseline score of 3 is appropriate as the description does not compensate or enhance parameter understanding.

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

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

The description '滚动到页面或元素顶部' clearly states the action (scroll to top) and target (page or element), which is specific and actionable. However, it does not explicitly differentiate from its sibling 'scrollToBottom', though the distinction is implied by the action name. This makes it clear but lacks explicit sibling differentiation.

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

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

The description implies usage for scrolling to the top of a page or element, but does not provide explicit guidance on when to use this tool versus alternatives like 'scrollToBottom' or other navigation tools. It offers some context through the parameter description for 'selector', but no clear when-not-to-use or alternative recommendations are stated.

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

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

No annotations are provided, so the description carries full burden. It mentions waiting for an element to appear, implying it's a blocking operation, but doesn't disclose key behavioral traits: that it waits up to a timeout (default 30000ms), can wait for different states (attached/detached/visible/hidden), might throw errors on timeout, or that it's specific to browser/page interactions. This leaves significant gaps for a tool with potential side effects.

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

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

The description is a single, efficient sentence in Chinese that directly states the tool's purpose without any fluff. It's appropriately sized and front-loaded, with every word contributing to understanding. No wasted words or unnecessary elaboration.

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

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

Given no annotations, no output schema, and a tool with 4 parameters (including timeout and state with behavioral implications), the description is incomplete. It doesn't cover return values (e.g., success/failure, element reference), error conditions, or the interactive nature in a browser context. For a waiting tool with potential timeouts and state dependencies, more context is needed.

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

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

Schema description coverage is 100%, so the schema already documents all parameters (pageId, selector, state, timeout) with descriptions and defaults. The description adds no additional meaning beyond what's in the schema—it doesn't explain parameter interactions, provide examples, or clarify semantics. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the action ('等待' meaning 'wait for') and the target ('指定选择器的元素出现' meaning 'element matching specified selector to appear'), which is specific and unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'waitForTimeout' or mention that this is for browser/page interaction context, leaving room for slight improvement.

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 that this is for waiting on DOM elements in a browser context, nor does it differentiate from sibling tools like 'waitForTimeout' (which waits for a time period) or 'getElementHTML' (which retrieves without waiting). No explicit when/when-not or alternative recommendations 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 states the action ('等待') without details on execution (e.g., blocking vs. non-blocking, error handling, or effects on browser state). For a tool with potential side effects in automation, this is inadequate, leaving key behavioral traits unspecified.

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, efficient sentence in Chinese ('等待指定毫秒数'), which is front-loaded and wastes no words. It directly conveys the core function without unnecessary elaboration, making it highly concise and well-structured for its 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 complexity of a browser automation tool with two parameters and no annotations or output schema, the description is incomplete. It doesn't cover behavioral aspects, usage context, or return values, leaving gaps that could hinder correct tool invocation. For a tool in this domain, more context is needed to ensure proper use.

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

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

Schema description coverage is 100%, with clear parameter descriptions in the schema ('等待的毫秒数' for 'ms', '页面ID' for 'pageId'). The description adds no additional meaning beyond the schema, such as explaining why both parameters are needed or their interaction. Baseline 3 is appropriate since the schema fully documents 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 '等待指定毫秒数' (wait for specified milliseconds) states a clear purpose with a verb ('等待') and resource ('毫秒数'), but it's vague about context. It doesn't specify this is for browser/page operations or distinguish it from generic timing tools, though sibling tools suggest a browser automation context. The purpose is understandable but lacks specificity about its domain.

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 use cases like waiting for page loads, animations, or delays in browser automation, nor does it reference sibling tools like 'waitForSelector' for comparison. Without context, users might misuse it for generic delays outside its intended scope.

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