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

No annotations provided, so description must compensate. It states requests are aborted, but lacks details on scope (per-session?), side effects, or whether it's persistent. Basic disclosure but missing depth.

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

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

Two sentences with no wasted words. However, for a tool with 2 parameters and no schema descriptions, it is under-specified rather than optimally concise. Could include more detail without becoming verbose.

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

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

Given 2 parameters, no schema descriptions, and an output schema (not shown), the description lacks guidance on pattern syntax, scope, and return values. Incomplete for effective tool 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 coverage is 0%, so description must explain parameters. It only mentions patterns with examples, but no format details. session_id parameter is not explained. Minimal addition over schema.

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

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

Description clearly states the verb 'Abort' and resource 'requests matching glob patterns'. Provides examples and use case, distinguishing it from sibling tools like browser_unblock_urls.

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

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

Gives context for when to use: 'to save proxy bandwidth or strip trackers/images'. Does not explicitly state when not to use, but the sibling list includes the complementary unblock tool, implying the context.

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

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

No annotations exist, so description carries full burden. It mentions the underlying mechanism (CDP Page.captureSnapshot) and return value (file path), but does not disclose potential side effects, authentication needs, or file size limits. Adds some useful technical detail but not extensive behavioral context.

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

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

The description is concise (3-4 lines) and front-loaded with core purpose. However, it could be structured more clearly, e.g., separating behavioral notes from usage. Still efficient overall.

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 output schema exists but is not described, and parameters are undocumented, the description lacks sufficient completeness. It does not cover error behavior, file overwrite policy, or output file format details important for a mutation/save tool.

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

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

Schema description coverage is 0%, yet the description offers no explanation of the two parameters (output_path, session_id). It only mentions returning a file path, leaving the agent to infer parameter semantics from names alone. Insufficient compensation for missing schema descriptions.

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

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

The description clearly states the tool saves a full page as MHTML archive via CDP, listing captured features (iframes, shadow DOM) and specifying 'for debugging/forensics'. It differentiates from siblings like screenshot and PDF by format and purpose.

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

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

The description gives context ('debugging/forensics') and specifies 'Chromium only', which helps in use-case selection. However, it does not explicitly state when not to use or list alternative tools like browser_screenshot or browser_pdf_save.

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 effectively discloses key behavioral traits: it uses a CDP input event with isTrusted=true, avoids pixel guessing, and returns a fresh ARIA snapshot. It does not mention potential side effects like triggering navigation or state changes, but the disclosure of the input mechanism is sufficient for understanding its behavior in context.

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

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

The description is a single paragraph with essential information front-loaded. It is concise and avoids unnecessary elaboration. Every sentence adds value: purpose, advantage over sibling, technical detail, platform constraint, and return value. Slightly longer than necessary but 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 the tool's moderate complexity (CDP input event, four parameters, output snapshot), the description covers the main aspects: mechanism, differentiation, return value. However, it lacks details on parameter semantics and potential error conditions (e.g., if ref is invalid), and does not mention the output schema explicitly. Still, it is largely complete for typical 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?

Input schema coverage is 0% and the description only implicitly explains the 'ref' parameter by stating the element is identified by [ref=...]. The other parameters (session_id, button, double) are not described at all. Given the low schema coverage, the description should add more parameter-level detail, but it does not.

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

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

The description clearly states the tool clicks an element by its [ref=...] using a trusted Chromium CDP input event, and explicitly distinguishes it from browser_mouse_click and browser_click by highlighting the technical advantages (cursorless, no pixel guessing, isTrusted=true). This makes the purpose highly specific and differentiated from siblings.

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

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

The description explicitly states 'Preferred over browser_mouse_click' and provides reasons for preference, along with the limitation 'Chromium only'. It gives clear context on when to use this tool (for bot-detection evasion) but does not explicitly state when not to use it (e.g., when a visible cursor is desired). Still, the guidance is strong and practical.

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 provided. The description does not disclose potential destructiveness, required permissions, or that raw commands can harm browser state. Only mentions Chromium limitation.

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?

Very concise - one main sentence and a line of examples. Front-loaded with purpose. Every sentence is informative.

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

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

Lacks output format description, error handling, or safety warnings. For a raw command tool that can do anything, more context is needed about what to expect.

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

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

Schema coverage is 0%. The description helps by showing example method and parameter patterns, but doesn't explain the params or session_id objects individually. Some value added but incomplete.

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

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

The description clearly states it sends a raw CDP command and returns the result, with specific examples like Network.getResponseBody. It differentiates from siblings by being the low-level escape hatch.

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

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

Explicitly calls itself an escape hatch for unsupported CDP capabilities, implying use only when other tools don't cover the need. Doesn't list alternative tools but provides guidance.

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

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

No annotations provided, so description carries full burden. It discloses the core behavior (removing highlights) but lacks details on scope, side effects, or prerequisites. Adequate but minimal.

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

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

Single, front-loaded sentence with no wasted words. Efficient and to the point.

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

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

Even for a simple tool, the description omits the optional session_id parameter and does not explain expected output or edge cases. Incomplete given the availability of an output schema.

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

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

The input schema has one optional parameter (session_id) with 0% description coverage in schema. The description does not mention or explain this parameter, providing no added meaning.

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

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

The description explicitly states the action (Remove) and the resource (highlight outlines) and references the companion tool browser_highlight, clearly distinguishing it from siblings.

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

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

The description implies usage after browser_highlight to remove outlines. It does not specify when not to use, but for a simple cleanup tool, the context is clear.

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

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

The description discloses that the tool returns a fresh snapshot after clicking, which is important behavioral context. However, with no annotations, it lacks details on error handling, loading waits, or behavior for missing elements.

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

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

The description is extremely concise with two short sentences. It is front-loaded with the action and resource, and every sentence adds value. No superfluous content.

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

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

Given the tool has 4 parameters with no schema documentation and no annotations, the description is insufficient. It does not cover parameter details, error conditions, or usage context beyond the basic action. An output schema exists but its content is unknown.

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

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

Schema description coverage is 0%, and the description adds no meaning to parameters. It does not explain the format of 'ref', the purpose of 'session_id', possible values for 'button', or the effect of 'double'. The description fails to compensate for the lack of schema documentation.

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

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

The description clearly states the tool clicks an element by snapshot ref, including iframe elements. It is specific and unambiguous, but does not explicitly distinguish from sibling tools like browser_mouse_click or browser_hover.

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

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

The description provides no guidance on when to use this tool vs alternatives (e.g., browser_hover, browser_mouse_click). It does not mention prerequisites, such as obtaining a snapshot first, nor when not to use it.

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

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

With no annotations, the description must fully disclose behavioral traits. It mentions 'free its browser' but lacks details on side effects, permissions, or error conditions. The destructive nature is implied but not explicitly stated.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It efficiently communicates the core action.

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

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

Given the tool has one required parameter and an output schema, the description is minimal but adequate for a simple close operation. However, it lacks mention of return value or typical usage scenarios.

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

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

The input schema has one parameter (session_id) with 0% description coverage, and the tool description adds no additional meaning, format, or constraints. The agent must rely solely on the parameter name and type.

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

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

The description clearly states the tool closes a session and frees its browser, specifying the verb 'close' and resource 'session', distinguishing it from sibling tools like browser_list_sessions or browser_new_session.

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

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

The description provides no guidance on when to use this tool, when not to use it, prerequisites, or alternatives. The agent must infer usage solely from the tool's name and purpose.

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 provided. The description does not disclose important behavioral traits such as whether it clears messages after reading, if it returns all messages since session start, or if it requires an active session. Limited insight beyond the basic return type.

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 short (one sentence), which is concise but lacks necessary details. It could be expanded to cover key aspects without becoming verbose.

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

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

Despite having an output schema, the description omits important context about session handling and the scope of console messages. For a tool with one optional parameter, the description should clarify its role to be 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 0%. The description does not mention the optional session_id parameter, its purpose, or how it affects the output. The agent gets no help understanding the parameter from 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 tool returns console messages with type and text from the current page, which is a specific verb+resource that differentiates it from sibling tool browser_ws_messages (WebSocket messages).

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

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

No guidance on when to use this tool versus alternatives like browser_ws_messages or when not to use it. The description lacks context for optimal usage.

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

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

No annotations provided, so the description must fully disclose behavior. It states it removes all cookies (destructive), but does not explain the scope of 'context' (current page vs. entire session), irreversible nature, or any side effects.

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

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

The description is a single sentence, very concise. It front-loads the action and resource, but lacks elaboration on key details. It is efficient but could be more informative 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 sibling tools and one parameter, the description is incomplete. It does not explain the role of session_id or differentiate from local storage clearing tools. The output schema exists but the description fails to provide sufficient context for correct invocation.

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

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

The only parameter, session_id, has 0% schema description coverage and is not mentioned in the tool description. The agent cannot infer its purpose or effects, which is a significant gap.

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

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

The description clearly states the verb 'Remove' and the resource 'all cookies in the context.' It distinguishes from sibling tools like browser_cookie_delete (removes specific cookie) by specifying 'all,' but does not define 'context' which may lead to ambiguity.

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

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

No guidance on when to use this tool versus alternatives like browser_cookie_delete or browser_cookie_list. The description does not mention conditions, prerequisites, or when to avoid using it.

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

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

No annotations provided. Description only indicates a destructive action ('delete') but does not disclose side effects, permissions, or behavior of the optional session_id parameter.

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

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

Single sentence is concise but lacks detail needed for effective use. Balance between brevity and completeness is poor.

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 (2 parameters, no annotations, output schema exists), description omits parameter semantics and usage context. Incomplete for reliable invocation.

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

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

Schema coverage is 0% and description adds no meaning beyond parameter names. The optional session_id parameter is not explained.

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

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

The description clearly states the verb 'Delete' and the resource 'cookie with the given name'. It is distinct from sibling tools like browser_cookie_clear (deletes all) and browser_cookie_get (retrieves).

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

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

No guidance on when to use this tool versus alternatives like browser_cookie_clear or browser_cookie_set. Does not mention session context or prerequisites.

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

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

No annotations provided. Description mentions null return for absent cookie, which is helpful. However, no details on idempotency, side effects, or permissions. For a simple read operation, it is adequate but lacks depth.

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

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

Single sentence with clear front-loaded action. Zero wasted words. Perfectly concise for the function's simplicity.

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

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

Given an output schema exists (context signal), return values are likely documented elsewhere. However, the description lacks explanation of the session_id parameter and error handling. For a simple getter, it is minimally complete but could be improved.

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 has 2 parameters with 0% description coverage. Description only mentions the 'name' parameter implicitly (cookie name), but completely omits the optional 'session_id' parameter. Does not add meaning beyond what the schema's field names imply.

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

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

Description clearly states verb 'get' and resource 'single cookie by name', and specifies return behavior ('or null if absent'). Distinguishes from siblings like browser_cookie_list and browser_cookie_set.

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

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

Implies usage when you know the cookie name, but does not explicitly state when to use this vs alternatives like browser_cookie_list or browser_cookie_get. No when-not or prerequisite conditions 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 must cover behavioral traits. It does not disclose whether cookies are from the current session, what 'context' means, or any access implications. The description is too brief for a tool with no annotations.

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

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

The description is a single sentence, concise and to the point, with no wasted words.

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

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

The tool has 2 optional parameters and an output schema, but the description lacks details about the expected output (even though output schema exists), and does not clarify the purpose of session_id. For a simple list operation, the description is too sparse to be fully helpful.

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

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

Schema coverage is 0% as the description does not mention parameter details. While 'optionally filtered to a url' hints at the url parameter, the session_id parameter is not explained. The description adds minimal value beyond the schema, failing to compensate for low coverage.

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

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

The description clearly states the tool lists cookies in the context, optionally filtered by URL. It uses a specific verb-resource combination that distinguishes it from sibling tools like browser_cookie_get or browser_cookie_set. However, 'context' could be more precise.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., browser_cookie_get for specific cookie retrieval). There is no mention of prerequisites or typical use cases.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It only states 'Set a cookie' without mentioning whether existing cookies are overwritten, if a session is required, or any side effects. This is insufficient for an AI agent to understand the tool's behavior safely.

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 short (one sentence), which is concise, but it lacks structure. It could benefit from a brief note on prerequisites or parameter grouping. It is front-loaded with the purpose, but the brevity means some needed information is missing.

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

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

Despite having an output schema and a simple operation, the description fails to cover all 6 parameters (only mentions url and domain+path) and does not explain the role of session_id or the expected behavior. It feels incomplete for an AI agent to use correctly.

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

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

Schema description coverage is 0%, so the description must add meaning. It explains the url vs domain+path relationship but does not describe the 'name', 'value', or 'session_id' parameters. The schema itself shows they are required or optional, but the description adds little beyond the schema for most parameters.

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

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

The description clearly states the verb 'Set' and the resource 'cookie', and it distinguishes between two methods of specifying the cookie location (url vs domain+path). This is specific and helps differentiate from sibling tools like browser_cookie_delete or browser_cookie_get.

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 tells when to use the tool (to set a cookie) and provides a choice of input formats. It does not explicitly state when not to use it or mention alternatives, but given the context of sibling tools, the guidance is clear enough for a simple operation.

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

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

No annotations are provided, so the description must fully disclose behavior. It states 'Returns a snapshot' but does not mention if the drag is a user simulation, whether it triggers events, or any side effects like scrolling or state changes. The behavioral transparency is insufficient.

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

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

The description is very concise with two short sentences. It gets straight to the point without unnecessary words. However, it is perhaps too brief, but conciseness is still good.

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 (drag and drop) and no annotations, the description is incomplete. It does not explain how to obtain refs, the prerequisites (e.g., active session), or the nature of the snapshot. The output schema exists but is not detailed; the description should still provide context.

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

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

Schema coverage is 0%, so the description must add meaning. It uses 'by refs' to hint at element references, but does not explain what refs are or the format expected. The session_id parameter is not mentioned at all. Minimal value added beyond the schema.

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

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

The description clearly states the action ('drag') and the resources ('one element onto another by refs'). It indicates that it returns a snapshot, and it distinguishes from other mouse-based drag tools like browser_mouse_drag by specifying 'by refs'. However, it does not explicitly differentiate from all sibling tools.

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

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

There is no guidance on when to use this tool versus alternatives (e.g., browser_mouse_drag). The description does not mention prerequisites or context for use, leaving the agent to infer usage.

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

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

With no annotations, the description should disclose behavioral traits like potential side effects. It only states 'evaluate' and gives read-only examples, but JavaScript execution can modify the page. The lack of warning about mutations or restrictions 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 front-loaded with the core purpose, followed by detailed parameter explanation and examples. It is slightly verbose but well-structured with logical flow. No wasted sentences.

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

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

Given no output schema and moderate complexity, the description covers the main functionality and frame_ref nuance, but lacks details on return value format, error handling, and session_id context. An AI agent may find it adequate but incomplete for precise invocation.

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

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

Schema coverage is 0%, so the description must compensate. It thoroughly explains frame_ref with cross-origin details and gives expression examples, but completely omits session_id. Two of three parameters are well-covered, but the missing explanation hurts completeness.

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

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

The description clearly states the verb 'evaluate' and the resource 'a JS expression or function in the page', accurately distinguishing it from sibling tools like browser_extract or browser_click. It specifies the action and scope without ambiguity.

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

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

The description implies usage for executing JavaScript and retrieving results, but provides no explicit guidance on when to use this tool versus alternatives or when not to use it. The frame_ref detail is context-specific but does not cover broader 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, description must fully disclose behavior. It mentions setting files and returning a snapshot but omits side effects (e.g., clearing previous files, file size limits, security restrictions) and does not explain the snapshot format.

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

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

Two short sentences, no fluff. Could be slightly more structured but is efficient.

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

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

Despite having an output schema, the description lacks details on input element identification, file path constraints, behavior with multiple files, and required page state. Incomplete for a file upload tool.

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

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

Schema description coverage is 0%, so description must explain parameters. Only hints at 'ref' and 'absolute paths', but does not define ref (CSS selector/XPath?), paths format, and session_id is unmentioned.

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

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

Clearly states the action: setting files on a file input element using a reference and absolute paths. Distinguishes itself among many browser tools as the file upload operation.

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

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

No guidance on when to use this tool versus alternatives (e.g., browser_fill_form, browser_type). Lacks prerequisites like needing an active file input element on the page.

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

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

No annotations are present, so the description must cover behavioral traits. It only mentions optional 'submit?' and 'clear?' without explaining their effects, and omits details on field validation, error handling, or session requirements.

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 short and front-loaded, but could be slightly more structured (e.g., bullet points for field properties). It is not verbose.

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

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

The tool has two parameters and an output schema exists (not shown), so return value explanation is unneeded. However, the description lacks prerequisites (e.g., active session) and does not clarify the role of 'session_id'. It feels incomplete for a form-filling operation.

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

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

The description adds structure for the 'fields' parameter (ref, value, submit?, clear?) but does not define these terms or explain the 'session_id' parameter. With 0% schema coverage, more detail was needed.

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

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

The description clearly states the verb ('Fill') and resource ('multiple fields') with a concise structure hint, distinguishing it from single-field tools like browser_type.

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

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

The description implies usage for bulk field filling but provides no when-not-to-use instructions or comparisons with sibling tools (e.g., browser_type for single fields).

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

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

With no annotations, the description correctly indicates the tool searches visible interactive elements and returns CSS selectors. It lacks details on error handling (e.g., no matches), performance, or side effects, but provides adequate behavioral context for a find operation.

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

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

The description is extremely concise: two sentences plus an example. Every sentence adds value, and the front-loading of the action makes it easy to grasp 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 there is no output schema, the description adequately explains the return format (list of matches with CSS selectors) and usage pattern. Missing details like match fields or error scenarios, but for the tool's purpose it is fairly complete.

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

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

The description explains the 'query' parameter well (searches text/placeholder/label/type), but does not mention the 'session_id' parameter at all. Since schema coverage is 0%, the description should document all parameters; it only partially compensates.

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 finds visible interactive elements whose text/placeholder/label/type contains the query, distinguishing it from siblings like browser_snapshot by specifying it's an escape hatch when snapshot returns only 'generic' references.

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

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

The description explicitly says to use this tool when browser_snapshot returns generic elements, providing a clear when-to-use scenario. However, it does not explicitly state when not to use it or alternative tools for other cases.

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

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

With no annotations, description bears full burden. It only states output type ('stable CSS selector') but does not disclose behavioral traits like required element state, side effects, or error conditions.

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

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

Single sentence, 14 words, front-loaded with action and object. Efficient but omits critical information that could be included without increasing length significantly.

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

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

Despite having an output schema, description lacks usage context, prerequisites, and behavioral details. Sibling tools are numerous, increasing the need for contextual guidance that is absent.

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

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

Schema has 0% coverage; description only mentions 'by ref' without explaining what 'ref' means or how to obtain it. The optional 'session_id' parameter is not described at all.

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

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

Description clearly states verb 'Return', object 'stable CSS selector', source 'element (by ref)', and purpose 'for use in code/tests'. It uniquely identifies the tool's function among many browser siblings.

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

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

No guidance on when to use this tool versus alternatives. Does not mention prerequisites or scenarios where it is appropriate or inappropriate.

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

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

With no annotations, the description carries the full transparency burden. It explains that the tool pre-grants permissions and dismisses prompts automatically, and mentions scope via origin. However, it does not disclose side effects, idempotency, or the behavior of the session_id parameter, which is left unmentioned.

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

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

The description is concise and well-structured. It starts with the main purpose, uses bullet points for parameter explanations, and provides actionable guidance in a separate sentence. Every sentence adds value 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 presence of an output schema and the tool's moderate complexity, the description covers the main use cases and behavior. However, it lacks explicit prerequisites (e.g., an active session) and does not mention error conditions or edge cases, making it slightly incomplete.

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

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

With 0% schema coverage, the description must add meaning for all parameters. It explains 'permissions' with examples and 'origin' with scope, but completely omits 'session_id'. This gap is significant, leaving the agent partially uninformed.

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: 'Pre-grant browser permissions so the native prompt never blocks the flow.' It uses specific verbs and resources, and distinguishes from siblings like browser_set_geolocation by focusing on permission grants rather than setting values.

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

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

The description provides explicit timing guidance: 'Call this before navigating to a page that requests permissions, or immediately when a permission prompt appears.' However, it does not discuss when not to use the tool or how it compares to alternatives like browser_handle_dialog, which might handle permission prompts differently.

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

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

With no annotations, the description carries full burden. It explains the accept/dismiss behavior via the accept boolean and mentions prompt_text for filling prompts before accepting. It also notes that dialogs remain open until handled, which is key behavioral info.

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 two sentences, no fluff, and front-loads the core action. Every sentence adds value.

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

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

For a simple dialog handling tool, the description covers most aspects: purpose, main behavior, and two of three parameters. Missing session_id explanation is a minor gap. Output schema exists, so return value details are not required.

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

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

Schema coverage is 0%, so description must compensate. It explains accept (accept or dismiss) and prompt_text (fill prompt before accepting), but does not explain session_id, leaving a gap. Two of three parameters are covered.

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: accepting or dismissing JS dialogs (alert/confirm/prompt). It specifically identifies the action and resource, distinguishing it from sibling tools which cover other browser interactions.

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

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

The description implies when to use it (when a dialog is open) and notes that dialogs stay open until handled, but does not explicitly state when not to use it or mention alternatives. No sibling tool addresses dialogs, so context is clear.

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

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

Clearly warns that the tool CLOSES the session because Playwright flushes HAR only on context close. Annotations are absent, so description carries full burden – it adequately discloses the side effect but doesn't cover error conditions or what happens if no session exists.

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

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

Description is compact with front-loaded purpose. The checkpoint pattern adds valuable usage context without being verbose. Could be slightly shorter, but every sentence serves a 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 2 optional parameters and a moderate complexity tool, the description covers the key side effect (session close) and provides a usage pattern. Missing session_id param explanation, but overall it's quite complete for the function.

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

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

Schema description coverage is 0%, so description must compensate. It explains output_path with default behavior and example, but session_id is completely undocumented. Only one of two parameters gets semantic context.

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

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

The description clearly states 'Finalize and return the HAR file path for a recording session' – a specific verb and resource. It distinguishes itself from 70+ sibling browser tools by being the only HAR export function.

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

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

Explicitly says use only with sessions created with record_har=True and provides a detailed non-destructive checkpoint pattern for continuing browsing after export, including exact steps and alternative tools (browser_storage_state, browser_new_session).

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It reveals the color (magenta) and that it draws an outline, but omits details such as whether the highlight persists, whether it scrolls to the element, or if it requires the element to be visible. The description is adequate for a simple action but lacks depth.

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

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

The description is a single sentence that immediately states the action ('Draw a magenta outline around an element (by ref)') and appends a practical usage note. It is front-loaded with the core purpose and contains no wasted words.

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

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

Given the tool's simplicity, the description covers the essential purpose and a key use case. The existence of an output schema (not described) is expected. The description is nearly complete, but could mention that highlights are cleared via a sibling tool or that the highlight is temporary.

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

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

The schema has 0% description coverage, so the description must compensate. It only mentions 'by ref' for the ref parameter, without explaining what a ref is or how it relates to the element. The session_id parameter is entirely ignored. This fails to add sufficient meaning beyond the schema's parameter names.

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

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

The description clearly states the tool's action: 'Draw a magenta outline around an element (by ref)'. It specifies the color (magenta), the target (element), and the identifier (ref). This distinguishes it from sibling tools like browser_clear_highlights.

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

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

The description includes the practical hint 'handy before a screenshot', which provides a clear use case. While it doesn't explicitly mention when not to use it or list alternatives, the sibling context (e.g., browser_clear_highlights) implicitly guides when to use this tool.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only says 'Returns a snapshot' but does not mention whether hover triggers events, whether it is destructive, or any side effects.

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

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

Very short and front-loaded, but too terse. Missing essential context that would help the agent use the tool correctly.

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?

While output schema exists and likely documents the snapshot return, the tool is for browser interaction and lacks guidance on parameter semantics and usage. Incomplete for the complexity involved.

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

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

Schema coverage is 0% (no descriptions in schema). The description adds no meaning beyond 'by ref', leaving 'ref' and 'session_id' undefined. An agent cannot infer what format 'ref' should be (e.g., selector, XPath, internal ID).

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 ('hover') and the resource ('element by ref'), and mentions the return value ('snapshot'). It distinguishes from sibling tools like browser_click or browser_scroll.

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

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

No guidance on when to use this tool versus alternatives. Does not specify prerequisites, such as requiring the element to be visible or the need for a session.

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

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

No annotations provided, so description carries full burden. Discloses the typing action, delay simulation, and return of snapshot. Does not detail potential side effects (e.g., overwriting existing text) or permission requirements.

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?

Concise, well-structured with bullet points and a clear pattern example. Every sentence adds value 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 simplicity and presence of an output schema, the description covers key use cases and integration patterns. Minor lack of parameter documentation for session_id prevents a perfect score.

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

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

Schema has 3 parameters with 0% description coverage. Description adds meaning to 'delay' (simulates human typing) and implies 'text' usage. 'session_id' is not described, leaving a gap.

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

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

The description clearly states the action ('Type text') and the resource ('currently focused element'). It explicitly distinguishes this tool from siblings like browser_type and fill() by mentioning scenarios where those fail.

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

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

Provides specific when-to-use scenarios: for contenteditable rich-text editors and as an escape hatch for iframe fields. Includes a usage pattern (mouse_click then keyboard_type). No explicit when-not, but context suffices.

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 implies a read-only operation via 'list', but does not explicitly confirm non-destructiveness or any other behavioral traits.

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

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

A single sentence that is front-loaded and directly describes the tool's function with no unnecessary words.

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

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

Given no parameters and an existing output schema, the description adequately lists return fields. Could mention that it returns an array, but overall sufficient.

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

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

The input schema has zero parameters with 100% coverage, so baseline is 4. The description adds no parameter info, which is acceptable as none exist.

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

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

The description clearly states the verb 'list' and the resource 'all open sessions' with specific return fields (url, tab count, identity). It is unique among sibling tools, as no other tool lists sessions.

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 or alternatives. While the tool is simple with no parameters, the description does not indicate scenarios or exclusions.

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

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

The description discloses that the operation is scoped to the current origin, which is beyond the name. However, without annotations, it lacks details on irreversibility, impact on other storage types, permission requirements, or synchronous behavior. It meets minimal expectations but does not fully compensate for the absence of annotations.

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

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

The description is very concise (one sentence), containing no superfluous words. It could be improved by including parameter information, but as a standalone statement it is efficiently 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 the tool's simplicity, the description captures the core behavior (clear all localStorage for current origin) and there is an output schema presumably covering return values. However, the lack of parameter explanation and usage context leaves gaps for a complete understanding.

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

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

The input schema has one optional parameter (session_id) with no description in the schema, and the tool description does not explain its purpose or effect. With 0% schema description coverage, the description should compensate but fails to add any meaning to the parameter.

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

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

The description clearly states the action ('clear') and the resource ('all localStorage for the current origin'), leaving no ambiguity about what the tool does. It distinguishes from siblings like browser_cookie_clear or browser_sessionstorage_clear by the specific resource mentioned.

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

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

The description provides no guidance on when to use this tool versus alternatives such as browser_localstorage_remove (to remove specific items) or browser_cookie_clear. The agent is not informed about prerequisites or context for invoking this tool.

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

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

With no annotations, the description must disclose behaviors. It mentions the return value ('null if absent'), which is a key behavioral detail. However, it does not state that the operation is read-only, or describe error conditions or storage limitations.

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

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

The description is a single, front-loaded sentence with no redundant words. It efficiently conveys the core functionality.

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

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

For a simple getter, the description covers the basic operation and null behavior, but omits explanation of the optional session_id parameter and return format. It is adequate but not thorough.

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

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

Schema coverage is 0%, so the description should explain parameters. It only mentions 'by key', partially covering the 'key' parameter but ignoring 'session_id'. No detail on parameter types or formats.

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

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

The description clearly states the verb ('get') and resource ('localStorage value by key'), and specifies the return behavior ('null if absent'). It distinguishes itself from siblings like browser_localstorage_set and browser_localstorage_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?

No guidance on when to use this tool versus alternatives such as browser_localstorage_list (to get all keys) or browser_sessionstorage_get. The description does not mention prerequisites or context.

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

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

No annotations provided, so description carries full burden. It states it lists all pairs for the current origin, implying a safe read operation. However, it does not disclose whether it returns an empty list, performance implications, or any side effects. For a simple list tool, this is minimally adequate but lacks depth.

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

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

The description is a single sentence, efficiently stating the core function. No wasted words. However, it could be expanded slightly to cover parameters or output without sacrificing 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 no output schema and only a brief description, the tool lacks context on return format (e.g., list of objects with key/value), behavior for empty storage, and the role of session_id. The description is too terse for an agent to reliably invoke without additional 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 only parameter, session_id, is documented only in the schema with a type and default. The description does not explain its purpose, how it affects the listing, or how to use it. With 0% schema description coverage, the description fails to compensate, leaving the agent uninformed.

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

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

Description clearly states the tool lists all localStorage key/value pairs for the current origin. The verb 'List' and resource 'localStorage key/value pairs' are specific, and it distinguishes from siblings like browser_localstorage_get (which likely gets a single key) and browser_localstorage_set.

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

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

No guidance on when to use this tool versus alternatives like browser_localstorage_get or browser_sessionstorage_list. No mention of prerequisites, context, or when not to use it.

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

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

No annotations are provided, so the description must fully disclose behavior. It only states removal but does not mention error handling when key is missing, side effects, or the role of session_id. The removal action implies irreversibility but this is not explicit.

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

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

The description is a single short sentence, but it sacrifices informative content for brevity. It is under-specified rather than concisely comprehensive.

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

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

Given the absence of annotations, low schema coverage, and a required parameter, the description fails to provide sufficient context. It does not explain the output, prerequisites, or behavioral nuances like session isolation.

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

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

Schema description coverage is 0%, meaning the schema lacks parameter descriptions. The tool description adds nothing about the 'key' parameter or the optional 'session_id'. The agent must infer meaning solely from parameter names and titles.

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 ('Remove') and resource ('localStorage key'). It distinguishes from siblings like browser_localstorage_clear (which removes all keys) through the verb 'remove' vs 'clear' and the explicit mention of 'a key'. However, it could be more specific about removing a single key.

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

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

No guidance on when to use this tool versus alternatives like browser_localstorage_clear, browser_localstorage_set, or browser_sessionstorage_remove. The description simply states the action without context or exclusions.

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

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

No annotations are provided, and the description is minimal. It does not disclose whether setting a key overwrites existing values, persists across sessions, has size limits, or requires an active session.

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 (one sentence) but at the expense of necessary details. It could be longer to add value.

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

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

Given the output schema exists, return values are covered, but the description lacks information on behavior, overwrite rules, and session scoping.

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

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

Schema description coverage is 0%, and the description adds no additional meaning to the parameters beyond their names. The role of session_id is not explained.

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 sets a localStorage key to a value, using a specific verb and resource. It is easily distinguishable from sibling tools like browser_localstorage_get, browser_localstorage_list, etc.

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

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

No guidance on when to use this tool versus alternatives like browser_cookie_set or browser_sessionstorage_set. The description does not mention prerequisites or context.

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

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

No annotations, so description carries full burden. Adds lifecycle info ('Cleared by browser_unblock_urls') and behavioral hint ('fault injection'). Could mention side effects on other requests but sufficient for basic understanding.

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

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

Two sentences, each serving a distinct purpose: definition and clearing behavior. No redundant or unclear phrasing. Front-loaded with key information.

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

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

Covers core behavioral aspects (mocking, clearing) but omits parameter details and output format. With 5 parameters and no annotations, more description would help. Output schema exists, reducing need for return info.

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 has 0% description coverage. Description only mentions 'glob pattern' indirectly through 'pattern' parameter. Other parameters (status, body, content_type, session_id) are not explained, leaving them underspecified.

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

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

Description clearly states verb 'fulfill requests' with resource 'matching a glob pattern' and purpose 'response mocking / fault injection'. It also distinguishes from sibling 'browser_unblock_urls' and implies contrast with 'browser_block_urls'.

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

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

No explicit when-to-use or when-not-to-use. Only implied that it is for mocking/fault injection and cleared by unblock_urls. Lacks prerequisites or alternatives, but purpose is clear enough for basic selection.

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

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

Without annotations, the description carries full burden. It explains basic behavior (click at coordinates, button types, multi-click) but does not disclose side effects, required permissions, or any limitations. It is adequate but not thorough.

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

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

The description is extremely concise with one sentence and a fragment, front-loading the purpose. Every word adds value, and there is no redundancy.

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

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

Given the tool has 5 parameters, an output schema (but no description of return), and many sibling tools, the description is too minimal. It lacks context on what happens after click, how session_id affects behavior, and does not differentiate well from other mouse tools.

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

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

Schema description coverage is 0%, so description adds meaning for button and clicks, but x and y are obvious, and session_id is not explained. The description partially compensates for missing schema descriptions but leaves one parameter undocumented.

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

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

The description clearly states the action (click) and resource (absolute coordinates). It specifies available button options (left|right|middle) and multi-click via clicks parameter, distinguishing it from sibling tools like browser_click which likely operates on elements.

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

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

The description implies usage for precise absolute coordinate clicks but does not explicitly state when to use this tool versus alternatives like browser_click or browser_mouse_down. No when-not or exclusion criteria 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?

With no annotations, the description must disclose behavioral traits. It only states the action without mentioning prerequisites (e.g., mouse must be positioned), fallback behavior, or whether this can initiate a drag. Minimal transparency.

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

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

The description is a single concise sentence, which is efficient for a simple action. However, it lacks structure such as parameter details or usage hints, making it overly brief.

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 presence of an output schema and two parameters, the description should explain how mouse_down relates to other mouse actions (e.g., sequence with mouse_up). It omits the role of session_id and button, leaving the tool partially incomplete.

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

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

Schema description coverage is 0%, so the description must explain parameters. It does not mention 'button' (valid values? default left) or 'session_id' (purpose? optional). No parameter information is conveyed.

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 (press mouse button down) and the resource (mouse at current position). However, it does not explicitly distinguish from sibling tools like browser_mouse_click or browser_mouse_up, which might cause confusion for an AI agent.

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

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

No guidance is provided on when to use this tool vs alternatives (e.g., browser_click for a full click, browser_mouse_drag for dragging). The description lacks any contextual or conditional usage advice.

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

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

No annotations are provided, and the description does not disclose release behavior, coordinate system, or side effects. It only mentions 'left button held' but fails to clarify endpoint 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 very concise (one sentence) but sacrifices essential detail. Acceptable for a simple tool, but could be improved.

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 existence of sibling tools and no annotations, the description is insufficient for an agent to use correctly. It does not cover output or coordinate system.

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

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

The description adds minimal meaning beyond parameter names; it omits coordinate reference (viewport vs page) and ignores session_id. With 0% schema coverage, more detail is needed.

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

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

The description clearly states the action (drag) and the start/end coordinates, distinguishing it from click, move, and other mouse actions. However, it does not mention whether it simulates mousedown, mousemove, mouseup sequence, leaving some ambiguity.

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

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

No guidance on when to use this tool versus siblings like browser_drag or browser_mouse_down/browser_mouse_move. It does not provide context for selection.

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

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

No annotations are provided, so the description must fully disclose behavior. It only states movement to coordinates, without explaining whether events fire, preconditions, or 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 concise sentence that directly states the tool's purpose without extraneous words.

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

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

For a simple tool with three parameters and an output schema, the description misses session_id context and behavioral details, but its core action is sufficiently explained.

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

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

With 0% schema coverage, the description explains the x and y parameters as 'absolute page coordinates', adding meaning. However, the session_id parameter is not mentioned, leaving it undocumented.

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

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

The description uses specific verb 'Move' and resource 'mouse' with 'absolute page coordinates (x, y)', which clearly distinguishes it from siblings like browser_click or browser_hover.

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

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

No guidance on when to use this tool versus alternatives such as browser_hover or browser_click. The description does not provide context for appropriate use cases.

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

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

Without annotations, the description carries the burden of behavioral disclosure. It states 'at the current position' implying no movement, but does not disclose side effects like triggering a mouseup event, what happens if no button is pressed, or whether it affects all held buttons.

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

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

The description is a single concise sentence with no wasted words. However, it could include the default button for 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's simplicity and existence of an output schema, the description is marginally adequate but lacks information about return values, session handling, or interaction with other mouse tools.

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

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

Schema description coverage is 0%, so the description must add parameter meaning. It does not explain the 'button' parameter (default 'left') beyond the action, nor the 'session_id' parameter. No enums or allowed values are mentioned.

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

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

The description clearly states the action 'Release a mouse button' and specifies the context 'at the current position'. It effectively distinguishes from related sibling tools like 'browser_mouse_down' (press) and 'browser_click' (press and release).

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., browser_mouse_click or browser_drag). It does not mention prerequisites such as having previously pressed the mouse button.

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 correctly describes the relative scroll by delta_x and delta_y pixels, implying a one-time simulation. It does not mention side effects or requirements, but the action is straightforward and non-destructive.

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

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

The description is a single concise sentence that immediately conveys the tool's purpose and parameter meaning. There is no wasted text, and the information is front-loaded.

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

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

For a simple tool with an output schema, the description adequately covers the core action. However, it does not mention the need for an active browser session or how session_id relates to other browser tools. This omission reduces completeness.

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

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

The description explains delta_x and delta_y ('by (delta_x, delta_y) pixels'), compensating for the 0% schema coverage. However, the session_id parameter is not mentioned, leaving its purpose unclear. The partial explanation results in a score of 3.

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

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

The description clearly states the action 'scroll the mouse wheel' with specific units (pixels). It distinguishes this tool from siblings like browser_scroll (page scroll) and browser_mouse_move (mouse movement without wheel).

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 vs alternatives, such as browser_scroll. The usage is implied from the description, but no exclusions or context are provided. A score of 3 reflects the implied usage without further direction.

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

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

No annotations are provided, so the description must carry the full burden. It discloses auto-creation of sessions and the return snapshot format. However, it does not mention error handling, redirect behavior, or other side effects like state changes beyond session creation.

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

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

The description is concise and front-loaded with the core purpose. Each sentence adds value: returns snapshot, wait_until options, timeout, session creation. No redundancies or fluff.

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

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

Given the tool's complexity (navigation with various wait strategies) and the presence of an output schema (not shown but referenced), the description covers return value, timing parameters, and session behavior. It could be improved by mentioning common error scenarios or redirect handling.

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

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

Schema coverage is 0%, but the description adds meaning to three of four parameters: wait_until (explains options), timeout_ms (relates to navigation timeout), and session_id (notes auto-creation). The url parameter is obvious from context. This compensates well for the lack of schema descriptions.

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

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

The description clearly states 'Navigate to a URL' and specifies the return value (ARIA snapshot). This directly explains the tool's primary function and distinguishes it from sibling navigation tools like browser_navigate_back or browser_reload.

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 detailed guidance on the wait_until parameter, explaining different values and their trade-offs (e.g., preferring default over 'load'). It also mentions auto-creation of sessions. However, it lacks explicit instructions on when to use this tool versus alternatives like browser_reload or browser_navigate_back.

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 provided, so description carries full burden. It discloses that the tool returns the new page's ARIA snapshot, which adds value beyond the schema. Missing details on failure modes or side effects, but the core behavior is clear.

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

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

Two sentences, no extraneous content. Front-loaded with the action, efficient 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 the tool's simplicity and the presence of an output schema (describing return type), the description is adequate for the core action. However, it fails to cover parameter semantics and usage context, leaving room for improvement.

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

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

Schema coverage is 0% and the description does not mention the sole parameter (session_id). The parameter is optional/nullable, but no explanation of its purpose or when to provide it. This is a critical gap.

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

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

Description clearly states 'Go back one entry in history' – a specific verb and resource. It distinguishes from siblings like browser_navigate_forward, browser_navigate, and browser_reload by specifying direction and granularity.

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?

Implied usage: use when you need to go back one step. No explicit when-to-use vs alternatives, no prerequisites or exclusions. Adequate for a simple tool but lacks guidance on session management.

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 provided. The description only mentions the return value but does not disclose what happens if no forward history exists, any side effects, or prerequisites. The safety profile is unclear.

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

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

One sentence that is front-loaded with the action, no filler. Every word earns its place.

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

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

For a simple tool with one optional param and output schema, the description is adequate but lacks usage guidelines and behavioral context. Return value is mentioned, but completeness is average.

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 sole parameter session_id is not described in the schema (0% coverage) and the description adds no meaning. The purpose of the parameter is implied but not stated.

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

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

The description states a specific verb ('Go forward') and resource ('one entry in history'), and mentions the output ('ARIA snapshot'). It clearly distinguishes from siblings like browser_navigate_back.

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 vs alternatives. Usage is implied (after navigating back), but no exclusions or when-not scenarios 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?

Discloses auto-capture for XHR/fetch and potential delayed body population for recent requests. With no annotations, this adds valuable behavioral context, though could mention whether it requires an active session or if it's read-only.

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

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

Two concise sentences, front-loaded with the key action and then details. Every sentence adds value with no redundancy.

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

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

Covers main functionality and important behavioral notes. Could be more complete by referencing the sibling tool for listing requests or explaining session_id. Output schema exists, so return value details not required.

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?

Describes index and url_contains parameters' purpose clearly, but does not explain session_id. Schema coverage is 0%, so description partially compensates but misses one parameter. No details on the format of url substring.

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

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

Clearly states 'Get one request's full detail' with specific resource. Differentiates from sibling 'browser_network_requests' by focusing on detail retrieval, but does not explicitly mention the sibling or when to use each.

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

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

Provides two matching methods (list index or url substring) but no guidance on when to prefer one over the other, nor when not to use this tool. No mention of prerequisites like session existence.

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 provided; description carries full burden. States it lists requests 'this session' (session-scoped) and supports filtering, but lacks detail on rate limits, side effects, or performance.

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

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

Two short, front-loaded sentences that efficiently convey purpose, filtering options, and pointer to sibling tool. No unnecessary words.

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

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

With only three optional parameters and an output schema present, the description sufficiently covers core functionality: listing and filtering network requests. The mention of browser_network_request covers the detail 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 has 0% description coverage. Description adds examples for resource_type ('xhr', 'fetch', 'document') and explains url_contains as substring match, but does not explain session_id, leaving some ambiguity.

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

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

Clearly lists network requests seen in session, specifying the data fields (method, url, status, resource_type). Differentiated from sibling browser_network_request which provides full details for a single request.

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

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

Explicitly mentions alternative browser_network_request for full details, providing usage context. However, no when-not-to-use or prerequisites 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?

Given no annotations, the description carries full burden. It discloses that a new session is created with a randomized fingerprint and isolated storage, and explains proxy pairing and persistent modes. It also states the return value. However, it omits potential side effects or failure scenarios.

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

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

The description is concise and well-structured, front-loading the main purpose and adding details in a logical order. Every sentence contributes meaningful information with no redundancy.

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

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

For a tool with 7 parameters, no required fields, no output schema, and no annotations, the description covers the core functionality and most parameters but misses 'label' and 'no_proxy'. It does not mention error handling or return format beyond stating it returns session info. Completeness is adequate but not thorough.

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

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

With 0% schema description coverage, the description must explain all parameters. It explains proxy_url, proxy_server, persistent, and hints at proxy_username/password, but does not cover 'label' or 'no_proxy'. The explanation adds value beyond the schema for some parameters but remains incomplete.

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 creates a fresh browser identity with a novel randomized fingerprint, isolated storage, and optional proxy pairing. It distinguishes itself from sibling tools like browser_new_session and browser_set_proxy by detailing unique features such as fingerprint randomization and persistent profiles.

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

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

The description provides clear context on how to use the tool, including default proxyless behavior and options for proxy pairing and persistence. However, it does not explicitly state when to use this tool versus alternatives or provide exclusions.

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

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

No annotations exist, so the description carries full transparency burden. It covers key behaviors: proxyless by default, proxy options, persistence, headless mode, humanization, recording HAR/video, storage_state reload, and extensions forcing persistent+headful. It also states that most tools auto-create a default session. The only gaps are missing details on rate limits or authentication, which are not critical for this 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 front-loaded with the core purpose and return value. Parameter explanations are grouped in a bullet-like structure (plain text but logically formatted). While a bit lengthy (several lines), each sentence provides necessary detail; no redundancy. It strikes a good balance between completeness and readability, though could be slightly more compact.

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

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

Given the high complexity (16 parameters, zero schema descriptions, no annotations), the description is exceptionally complete. It covers every parameter's behavior, side effects (extensions force persistent+headful), optionality, and return value. The only minor omission is the exact format of the returned id, but since it's a simple string, this is acceptable.

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

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

Schema description coverage is 0%, so the description must fully explain parameters. It does so thoroughly: for each parameter it explains purpose, defaults, constraints (e.g., extensions forces persistent+headful), and acceptable values (e.g., humanize: float, bool, or None). This adds immense value beyond the bare schema, making the agent capable of correct parameter choices.

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

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

The description opens with 'Create a new stealth browser session and make it current. Returns its id.' This clearly states the verb (create), resource (stealth browser session), and outcome (makes current, returns id). It distinguishes this tool from siblings like browser_close_session or browser_list_sessions, as it is the only session creation 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 explicitly notes that 'Most tools auto-create a default session, so calling this is optional.' This tells the agent when the tool is needed (custom settings) and when it's not (default behavior). It also explains proxyless default and how to override, providing clear context for usage. However, it does not explicitly list alternatives or when-not scenarios beyond the optionality statement.

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

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

The description discloses that the tool saves to PDF and returns a file path, which is basic behavior. With no annotations provided, it lacks details about side effects, permissions, or error conditions, which limits 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 with two short sentences, both front-loaded with essential information. No superfluous words.

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

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

Given the low schema coverage and no annotations, the description is incomplete. It does not specify prerequisites (e.g., a loaded page), the exact meaning of 'Chromium only', or details about the return value, leading to potential misuse.

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

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

The schema coverage is 0%, and the description does not explain the 'output_path' parameter (e.g., required format, default directory) or the 'session_id' parameter (e.g., when it is needed). This leaves the agent without crucial usage details.

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

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

The description clearly states the tool saves the current page as a PDF file, which is a specific verb+resource. However, it does not distinguish from sibling tools like 'browser_screenshot' or 'browser_capture_mhtml', leaving potential ambiguity.

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

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

The mention of 'Chromium only' provides a usage constraint but there is no explicit guidance on when to use this tool versus alternatives, nor what happens if not in a Chromium session.

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

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

With no annotations provided, the description must fully disclose behavior. It only mentions that the action returns a snapshot, but fails to describe side effects, focus requirements, whether keys are released, or if there are any timing considerations.

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

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

Single sentence with examples, front-loaded, no redundant words. Efficient and to the point.

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

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

Given the tool's simplicity and the presence of an output schema, the description covers the basic functionality. However, it lacks context on valid keys (only examples), session management, and interaction with other browser elements. Sibling tools are numerous, so more guidance would help agent selection.

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

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

Schema description coverage is 0%, so the description must compensate. It gives examples for the 'key' parameter but does not explain the 'session_id' parameter or its optional use. Missing details like allowed key values (beyond examples) or format.

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 ('Press a keyboard key'), specifies the resource ('keyboard key'), and provides concrete examples ('Enter', 'Escape', 'ArrowDown', 'Tab'). It distinguishes from sibling tools like browser_click or browser_keyboard_type.

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

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

No guidelines on when to use this tool versus alternatives like browser_keyboard_type or browser_fill_form. No mention of prerequisites (e.g., focus on an input element) or when not to use it.

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

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

No annotations are present, so the description carries full burden. It states the action and return value but omits details such as cache behavior, side effects, or whether the snapshot includes full accessibility tree.

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

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

Two concise sentences with no fluff. The information is front-loaded, though a touch more context could be added without harming conciseness.

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

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

Given the complexity of the browser tool ecosystem and lack of annotations, the description is too sparse. It fails to explain session_id, when to prefer reload over navigate, or details about the returned ARIA snapshot.

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

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

The schema has 0% coverage and the description does not explain the purpose of the optional 'session_id' parameter, leaving the agent with no additional semantic guidance.

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

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

The description clearly states the action ('Reload the current page') and the return value ('Returns the page's ARIA snapshot'), which is specific and distinct from sibling navigation tools.

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

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

The description implies when to use (wanting to refresh the page), but does not explicitly mention alternatives like navigate, navigate_back, or navigate_forward, nor when not to use.

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

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

With no annotations provided, the description must fully convey behavioral traits. It states that resizing affects layout and screenshot size, which is useful. However, it does not disclose other potential side effects (e.g., triggering re-renders, session impact). The information is adequate but minimal.

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

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

The description consists of two short, direct sentences. It front-loads the action ('Resize the page viewport') and adds only essential context. No extraneous words.

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

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

Given the tool's simplicity and presence of an output schema, the description covers the core functionality. It could mention error conditions or async behavior, but for a straightforward resize operation, it is sufficiently complete.

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

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

The input schema has 3 parameters (width, height, session_id) with 0% description coverage. The description provides an example ('1920x1080') hinting at width/height usage but does not explain valid ranges, units, or the purpose of session_id. This is insufficient compensation for the lack of schema descriptions.

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

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

The description uses a specific verb ('Resize') and resource ('page viewport'), and provides an example dimension '1920x1080'. It clearly distinguishes from sibling tools like screenshot or scroll by stating it affects layout and screenshot size.

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 changing viewport size but does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternative tools. The phrase 'e.g. 1920x1080' offers a typical use case but lacks comparative context.

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

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

With no annotations provided, the description carries full burden. It discloses capture modes, default vs. full_page vs. ref behavior, and the output_path file-writing behavior. However, it omits any mention of session handling or required permissions, which are relevant for context.

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

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

The description is concise with three focused sentences. The first sentence states the main purpose and default, the second elaborates modes, the third details output_path. No wordiness or 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?

Despite missing session_id and not explicitly stating the default return format (image bytes), the description covers key behaviors and use cases adequately for a low-complexity tool. It is sufficiently complete given no annotations or output schema.

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

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

Three of four parameters (full_page, ref, output_path) are explained in detail, adding meaning beyond the bare schema. The session_id parameter is not mentioned, leaving a gap. Overall, it compensates well for the 0% schema coverage.

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

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

The description clearly states the tool takes a PNG screenshot and distinguishes three capture modes (viewport, full page, single element). This specificity and differentiation from sibling tools like browser_snapshot earn a top score.

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

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

It provides clear context on when to use the output_path option for offloading large images to another tool. However, it does not explicitly mention when not to use this tool, nor does it discuss alternatives beyond the implied scenario.

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

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

Describes behavioral traits: pixel scrolling with direction/amount, element scrolling via ref, default values, returns a snapshot. No annotations provided, so description carries full burden and does well, though could mention non-destructive nature.

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?

Very concise: two sentences plus a bullet-like format. Front-loaded with the main action. Every sentence adds value without repetition.

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

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

Covers main functionality and usage context. Output schema exists for return values. Minor gap on session_id parameter, but overall complete for the tool's complexity.

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

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

Adds meaning to direction and amount (pixels, defaults) and ref (scrolls element into view, ignoring direction/amount). Session_id is not explained, but schema coverage is 0% so description compensates well for main 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?

Description clearly states it scrolls the page by pixels or scrolls an element into view, using specific verbs and resources. It distinguishes between two modes and from sibling tools like browser_scroll_to_bottom implicitly.

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

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

Explicitly says to use it for triggering lazy-loaded content or revealing off-screen elements, providing good context. Does not compare to sibling browser_scroll_to_bottom, but the use case is clear.

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