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

The readOnlyHint=false annotation already signals a mutating operation, and the description adds no behavioral context such as possible navigation, dialog triggers, or snapshot refreshing. With no output schema, the agent gets no insight into side effects or return behavior beyond the boilerplate action.

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

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

The description is one short sentence with no redundant filler and the verb is front-loaded. It is concise, though slightly too terse to convey the optional double-click and snapshot behavior.

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

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

For a simple click operation, the schema covers parameter mechanics and the description states the action, which is minimally viable. However, the lack of side-effect disclosure, alternative routing, and return-value guidance leaves meaningful gaps for an agent deciding whether to invoke it.

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

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

Schema description coverage is 100%, so the parameters are already documented in the structured schema. The description adds only the vague phrase 'provided element' and doesn't enrich the meanings of pageId, uid, dblClick, or includeSnapshot, so it stays at the baseline.

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

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

The description states the action ('Clicks') and the target ('provided element'), which is clear at a basic level and distinct from navigation or page-management siblings. However, it doesn't distinguish click from related interactions like hover or drag, and 'provided element' doesn't mention that the element must come from the snapshot uid.

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 click versus sibling tools such as hover, drag, type_text, or press_key. The dblClick parameter exists in the schema as an alternative interaction mode, but the description doesn't mention it or any exclusions.

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

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

Annotations already mark this as non-read-only, and the description adds the edge constraint that the last page cannot be closed. It does not describe failure behavior, side effects, or whether the close is permanent, but for a simple close action this is acceptable.

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

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

Two short sentences with no filler. The main action is front-loaded and the important constraint follows immediately.

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

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

For a one-parameter tool with a fully described schema and an annotation, the description covers the core action and the key edge case. An explicit pointer to list_pages in the main description would help, but the parameter description already provides that.

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

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

Schema description coverage is 100%, including an instruction to call list_pages to obtain pageId, so the description does not need to repeat parameter details. The description's 'index' wording slightly conflicts with the schema's 'ID' terminology but does not add meaningful new semantics.

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

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

The description states a clear action and resource: closes a page. It also adds a meaningful scope constraint: the last open page cannot be closed. However, saying 'by its index' while the schema names the parameter 'pageId' introduces minor terminology 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 second sentence provides an implicit usage boundary: do not try to close the last open page. It does not explicitly compare against alternatives such as select_page, new_page, or navigate_page, so the guidance is implied rather than fully explicit.

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

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

The annotations only provide readOnlyHint=false, which already signals a mutating operation. The description adds no behavioral context beyond the action itself: no mention of side effects, DOM changes, events triggered, or what happens after the drop. It essentially restates the tool name without disclosing the operational consequences.

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

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

The description is a single sentence with no filler, and the core action is front-loaded. It is concise and easy to parse, though it is also somewhat under-specified; there is nothing redundant, but there is little beyond the bare 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?

For a four-parameter interaction with no output schema, the description plus the fully described schema gives an agent enough to make a basic call. However, it does not explain the effect of includeSnapshot on the response or mention any behavioral caveats, so the context is adequate but not complete.

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

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

The input schema has 100% description coverage, and each property already explains its meaning: pageId, from_uid, to_uid, and includeSnapshot. The tool description adds no extra meaning about parameter relationships, constraints, or formats, so it stays at the schema baseline.

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 and resource: 'Drag an element onto another element.' It clearly identifies the core action and the two targets, which distinguishes it from sibling interaction tools like click, hover, and fill. Even without parameter details, the purpose is unmistakable.

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 drag-and-drop usage but does not explicitly state when to prefer it over alternatives or when not to use it. There are no prerequisites, exclusions, or alternative routing, so the agent must infer applicability solely from the verb.

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

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

Annotations include readOnlyHint: false, which implies this tool may have side effects, but the description doesn't elaborate on the nature of those effects (e.g., whether emulation is temporary, whether it affects the page state persistently, or if it requires specific permissions). The parameter descriptions hint at persistence (e.g., extraHttpHeaders persist across navigations), but the tool-level description doesn't summarize behavior beyond 'emulates'. It's not contradictory, but it doesn't add significant behavioral context beyond what parameters already state.

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

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

The description is a single sentence that is concise but very generic. It's not verbose or wasteful, but it's also not front-loaded with the most important info. It's acceptable, but could be more structured by listing the emulation categories (e.g., viewport, user agent, color scheme, etc.).

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 8 parameters, a required pageId, and no output schema. The description doesn't explain return values or side effects beyond what parameters imply. Given the number of parameters, a more comprehensive overview of what emulation types are supported and how they interact would be helpful. The schema is rich, but the tool description alone doesn't give an agent a complete picture of how to use these parameters together. There's no mention of clearing overrides or default behavior beyond parameter hints.

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

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

Schema description coverage is 100%, so each parameter is described. The description of the tool itself adds little beyond what's in the schema. The parameter descriptions are quite detailed (e.g., viewport format, enums for network conditions), so the schema does most of the heavy lifting. The tool description doesn't add extra meaning beyond 'these are the emulation options', so a baseline 3 is appropriate.

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

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

The description says 'Emulates various features on the target page', which is a clear verb+resource but lacks specificity about which features. It doesn't differentiate from siblings like resize_page (which is more specific) or navigate_page. However, the parameter list makes it clear it covers multiple emulation types (viewport, user agent, color scheme, etc.), so the purpose is reasonably clear, but could be more explicit about the range of emulation features.

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. For example, it doesn't mention that resize_page might be more appropriate for simple viewport changes, or that evaluate_script could be used for setting user agents. It only says 'emulates various features' without context on selection. There is no when/when-not guidance.

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

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

The description adds a meaningful behavioral constraint: returned values must be JSON-serializable because output is returned as JSON. However, annotations provide only readOnlyHint=false, and the description does not disclose potential side effects, navigation risks, or other execution consequences of running arbitrary page JavaScript, so the description only partially carries the behavioral burden.

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 filler. The action and target are front-loaded, and the key return constraint is stated immediately after. The description is compact and easily scannable.

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

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

The schema covers all parameters and the description explains the return format, which is important since there is no output schema. However, the description omits usage guidance and side-effect caveats for arbitrary code execution, and the non-read-only nature is only signaled by the minimal annotation. These gaps make the context only moderately complete.

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

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

Schema coverage is 100%, with all six parameters described, including examples for the function parameter. The description adds the JSON-serializability caveat for the return value, but otherwise does not explain parameter semantics beyond what the schema already provides. This meets the baseline.

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

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

The description clearly identifies the action ('Evaluate a JavaScript function'), the target resource ('inside the target page'), and the return mode (JSON). It is specific enough for an agent to understand what the tool does, and while it does not explicitly name a sibling alternative, no sibling appears to offer arbitrary JavaScript execution.

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 dedicated actions like fill, click, navigate_page, or take_snapshot. The description does not state exclusions, prerequisites, or cases where a more specific tool should be preferred, leaving the agent to infer usage context.

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

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

The description adds some behavioral context by specifying inputs, textareas, and select elements, which goes beyond the bare readOnlyHint=false annotation. However, it does not disclose whether existing content is overwritten, whether keystrokes are simulated, whether events are fired, or how checkbox and radio values are applied.

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 focused sentence that begins with the action and names the relevant resources. There is no filler, no repetition of schema details, and every word contributes to understanding the tool.

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

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

For a simple four-parameter tool with full schema coverage, an agent can likely invoke it correctly. However, the description lacks sibling differentiation, side-effect details, and behavior around existing values or snapshot responses, leaving some practical ambiguity.

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

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

Schema description coverage is 100%, with all four parameters clearly described, including value semantics for checkboxes, toggles, and radios. The description itself adds little parameter-level meaning beyond naming the supported element types, so the baseline of 3 is appropriate.

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

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

The description states a concrete action ('Type text', 'select an option') and the target resources ('input', 'text area', '<select>'). It is clear about what the tool does, but it does not differentiate it from siblings like type_text or fill_form, so it stops short of a 5.

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

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

There is no guidance on when to prefer fill over type_text or fill_form, and no when-not-to-use or alternative tooling is mentioned. The supported element types imply some usage scope, but not enough to choose correctly among overlapping siblings.

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

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

The readOnlyHint=false annotation already signals a mutating operation, and the description aligns by describing 'fill out.' It adds some behavioral context by emphasizing batch execution in 'one call' and claiming reliability, but it does not disclose partial-failure behavior, side effects, or response semantics.

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

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

The description is compact and well-structured: the first sentence defines scope, the second is a high-value routing directive, and the third is a concrete example. Every sentence earns its place with no fluff 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?

For a batched form-fill tool, the description provides purpose, usage precedence, element coverage, and a worked example, while the schema covers all parameter meanings. It lacks only explicit fallback conditions and direct response details, but those are minor given includeSnapshot is already documented in the schema.

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

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

Schema description coverage is 100%, so the schema already documents pageId, elements, and includeSnapshot fully. The description's example ('username, password, and check Remember Me') adds a helpful real-world mapping, but it does not add meaningful parameter syntax beyond what the schema provides.

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

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

The description states a specific verb ('fill out') and a specific resource ('multiple form elements') and enumerates the element types it covers. It also distinguishes itself from sibling tools by explicitly contrasting with 'fill' or 'click' calls.

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

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

It gives an explicit, strong usage directive: 'ALWAYS prefer this tool over multiple individual fill or click calls when interacting with forms,' and provides a rationale (faster, more reliable, fewer turns). It does not explicitly state when to fall back to single-element fill/click, so a small exclusion gap remains.

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

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

The readOnlyHint annotation already covers the safety profile, and the description does not contradict it. The description adds minimal behavioral context beyond the basic fetch action; it doesn't mention return format or error behavior, but for a simple read-only lookup this is acceptable.

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

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

Two efficient sentences with no filler. The primary action is front-loaded, and the pointer to the sibling tool earns its place by helping the agent choose 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?

For a simple read-only fetch tool, the description is complete: it identifies the resource, explains the selection mechanism, names the related list operation, and is backed by fully documented parameters and a readOnlyHint annotation. No critical information is missing.

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

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

Schema description coverage is 100%, so both pageId and msgid are already documented in the schema. The description reinforces that lookup is by message ID but does not add meaningful semantic details beyond the schema.

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

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

The description states a specific verb ('Gets'), a concrete resource ('console message'), and a precise selection mechanism ('by its ID'). It clearly distinguishes this tool from list_console_messages, which retrieves all 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?

The description explicitly names the alternative tool for fetching all messages and implies that this tool is for fetching a single message once its ID is known. It could be stronger by stating the prerequisite workflow (call list_console_messages first), but 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?

Annotations only provide readOnlyHint=false, which is vague. The description adds meaningful behavioral disclosure: it can save request and response bodies to files via requestFilePath/responseFilePath, and returns bodies inline when omitted. It does not mention permission requirements or other side effects, but the file-writing behavior is the key additional trait and is well covered.

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 filler. The first sentence states the core behavior and optional reqid fallback; the second gives the practical use case. Both sentences earn their place and the most important 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 tool with 4 parameters, a complete schema, and no output schema, the description sufficiently explains the return behavior (inline vs file) and typical usage. It could mention how to obtain a reqid (e.g., via list_network_requests), but that is inferable from sibling names and does not block correct invocation.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description restates the reqid optionality but adds no new parameter-level semantics beyond what the schema provides. Baseline 3 applies because the schema carries the burden.

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

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

The description clearly states the tool gets a network request, optionally by reqid, and falls back to the currently selected request. It also names the key use case (inspecting headers), which distinguishes it from the sibling list_network_requests. However, it does not explicitly contrast with that sibling, so it falls just short of a 5.

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

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

The description gives concrete context: use it to inspect request/response headers and directives. It implies the alternative (list_network_requests) for finding requests but never states 'use list_network_requests to list all requests' or when not to use this tool. This is clear context without explicit exclusions or named alternatives.

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

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

The only annotation is readOnlyHint=false, so the description carries the full burden of behavioral disclosure. It does not say what happens when no dialog is present, whether promptText applies only to specific dialog types, or what side effects accept/dismiss produce. This is a significant gap for a mutating action.

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

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

The description is a single, focused sentence that states the trigger condition and the action. There is no padding or redundancy, and the key 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 three-parameter tool with full schema descriptions, the description plus schema is minimally sufficient to make a basic call. However, it lacks behavioral context such as no-dialog behavior, whether promptText works with accept vs. dismiss, and potential errors, so it is not fully complete.

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

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

Schema description coverage is 100%: pageId, action, and promptText each already have meaningful descriptions. The tool description adds no parameter-level meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly names the resource (browser dialog) and the intended operation ('handle it'), and the trigger condition 'if a browser dialog was opened' adds practical context. It doesn't explicitly say accept/dismiss, but the schema enum fills that in. No sibling tool overlaps with dialog handling, so it is reasonably distinguishable.

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

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

The description gives a clear when-to-use condition: only when a browser dialog is open. It doesn't mention alternatives or exclusions, but among the listed siblings there is no other dialog-handling tool, so the guidance is adequate.

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

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

The annotation readOnlyHint: false is provided, but the description adds no behavioral context beyond it. It does not explain whether hover triggers asynchronous effects, waits for UI changes, or requires any specific conditions. Since annotations are present but the description offers no extra insight, it scores low.

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

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

The description is a single, concise sentence with no filler. It is front-loaded with the action. However, it is so terse that it borders on under-specification, but for pure conciseness it earns a 4.

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 action tool, the description lacks necessary context: no mention of hover effects, potential side effects, or how it interacts with the snapshot parameter. With no output schema and minimal guidance, it is incomplete for an agent to use effectively.

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

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

All three parameters have schema descriptions (100% coverage). The tool description itself adds nothing about parameters ('provided element' only hints at uid). Given high schema coverage, the baseline of 3 is appropriate; the description does not enhance the parameter understanding.

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

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

The description 'Hover over the provided element' clearly states a specific verb (hover) and resource (the provided element). It distinguishes from sibling actions like click, drag, or press_key, making its purpose unmistakable.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention typical scenarios (e.g., triggering tooltips, hover-dependent UI), prerequisites, or exclusions. Users must infer context from the tool name alone.

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

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

Annotations declare readOnlyHint=false, signaling this is not a pure read operation, and the schema's mode description already notes that navigation reloads the page and outputDirPath indicates report file output. The tool description itself adds little behavioral context beyond the performance exclusion, but it does not contradict the annotations.

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

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

Two short sentences carry the full purpose, category scope, exclusion, and sibling alternative with no filler. The main action is front-loaded, and the performance carve-out is stated immediately after.

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

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

The description plus schema covers purpose, scope, parameters, and the main sibling alternative, but with no output schema it leaves the report shape and return value unspecified. The description also relies on the schema to communicate side effects like navigation reloading and report output, which are important for an agent to anticipate.

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

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

The input schema has 100% parameter description coverage, so every parameter's meaning is already documented. The tool description adds no parameter-level detail beyond that, which lands it at the baseline 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 uses a specific verb ('Get') and resource ('Lighthouse score and reports'), and enumerates the exact audit categories: accessibility, SEO, best practices, and agentic browsing. It explicitly excludes performance and names the sibling performance_start_trace, making the tool's scope unambiguous.

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

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

The description states both what this tool is for and what it is not for: 'This excludes performance. For performance audits, run performance_start_trace.' This gives an agent a clear decision rule and a direct alternative when the audit request is performance-focused.

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

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

The readOnlyHint annotation already communicates that this is a safe read operation. The description adds useful context by stating the temporal scope ('since the last navigation'), but it does not disclose pagination behavior, return shape, or how filtering options affect output. This is comparable to the get_calls calibration example.

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

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

The description is a single, well-formed sentence with no filler. The core action, resource, target, and time scope are all front-loaded, making it easy for an agent to parse quickly.

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

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

For a read-only list tool, the rich input schema and readOnlyHint cover most operational needs. The description is brief but sufficient, though it could optionally mention that the result is a list of message objects, since no output schema is present.

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

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

Schema description coverage is 100%, so every parameter already has a clear meaning in the input schema. The description adds no parameter-level detail beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('List'), a clear resource ('console messages'), and a precise scope ('for the target page since the last navigation'). This naturally distinguishes it from sibling tools like get_console_message (singular) and list_network_requests (different resource).

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

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

The description gives no guidance on when to use this tool versus alternatives such as get_console_message or list_network_requests. No exclusions, prerequisites, or selection criteria are provided, leaving the agent to infer usage from the name and schema.

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

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

Annotations already declare readOnlyHint=true, so the safe-read nature is established. The description adds useful scoping context about target page and navigation window, but does not disclose ordering, pagination behavior, or what happens to requests across navigations beyond what the schema's includePreservedRequests parameter already hints at.

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 that names the action, resource, target, and time scope with no wasted words. Every phrase 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 read-only listing tool with fully documented parameters and a readOnly annotation, this description plus the schema covers the essential invocation needs. It does not describe the return shape or ordering, but 'lists ... requests' plus the schema provides enough guidance for correct use.

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

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

Schema description coverage is 100%, so all five parameters, including the required pageId and filter options, are already documented in the input schema. The description adds no additional parameter-level meaning, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Lists') and resource ('network requests for the target page') and adds a temporal scope ('since the last navigation'). It is clear about what the tool does, though it does not explicitly distinguish itself from the sibling get_network_request, which likely retrieves 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?

The description conveys a clear use context: listing recent network activity for a page after navigation. However, it does not state when to prefer an alternative such as get_network_request, nor does it mention any exclusions or conditions that would make another tool more appropriate.

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

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

The readOnlyHint annotation already covers the safety profile, and the description's 'Get' wording aligns with a read-only operation. However, the description adds little beyond the annotation, such as whether the result is a snapshot or includes all browser contexts.

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 front-loaded sentence with no filler. It immediately states the operation and the resource, which is ideal for a simple tool.

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

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

For a zero-parameter, read-only listing tool, the description tells the agent what it will get: a list of open pages. It does not specify the exact structure of each entry (e.g., page ID, URL, or title), and there is no output schema to fill that gap, but the missing detail is minor for simple enumeration.

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

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

The tool has zero parameters and 100% schema description coverage, so there is no parameter detail the description needs to supply. The baseline for a parameterless tool applies.

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

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

The description states a specific verb ('Get') and a specific resource ('pages open in the browser'). It is naturally distinct from siblings such as select_page, new_page, navigate_page, and close_page, which act on or create pages rather than listing them.

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

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

The intended use is clear: enumerate currently open browser pages before deciding which page to operate on. No explicit alternative or exclusion is named, but no sibling performs the same listing operation, so this is acceptable.

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

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

Annotations only indicate readOnlyHint=false, so the description carries the burden of explaining side effects. It confirms the navigation action but does not disclose page state changes, beforeunload handling, or other behavioral consequences beyond what the schema already lists.

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 compact sentence with the primary action front-loaded and no filler. Every phrase earns its place, and the fallback behavior is stated efficiently.

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 7-parameter tool with no output schema and sparse annotations, the description plus schema is minimally workable. It misses guidance on mode-specific parameter applicability and page targeting context, making it adequate for simple navigation but incomplete for more nuanced use.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds one useful semantic—omitting a URL falls back to the project URL—which is not in the schema, but it does not elaborate on the other six 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 states a specific verb and resource: navigate by URL, back, forward, or reload. It clearly communicates the core action and differentiates from the name alone, though it does not explicitly contrast with siblings like new_page or select_page.

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

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

The only guidance is 'Use project URL if not specified otherwise,' which addresses a default parameter value rather than when to choose this tool over alternatives. No sibling tools or exclusions are mentioned, leaving tool-selection decisions to inference.

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 states the core behavior (opening a tab and loading a URL) and is consistent with the readOnlyHint=false annotation. It does not add deeper behavioral context such as wait behavior, foreground effects, or what happens to the current page, though the schema covers timeout and background details.

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 make the core purpose immediately visible. However, the second sentence is not merely concise; it is inaccurate with respect to the required URL parameter, so it does not fully earn its place.

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

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

For a tool with four schema-documented parameters and no output schema, the description is minimal and leaves the agent without sibling-routing guidance. The contradictory 'project URL' fallback also makes invocation guidance unreliable, so the description is not complete enough for correct selection and calling.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no useful parameter-level semantics and actively confuses invocation by implying url can be omitted when it is required.

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

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

The description clearly identifies the action with a specific verb and resource: opening a new tab and loading a URL. It implicitly distinguishes itself from navigate_page by emphasizing 'new tab,' but it does not name a sibling or explicitly explain the difference from navigating an existing page.

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

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

The description provides no guidance on when to choose new_page over navigate_page or other page-management tools. The only usage hint, 'Use project URL if not specified otherwise,' conflicts with the schema, where url is required, and is therefore misleading.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds useful context that this read concerns insights highlighted from a trace recording, but doesn't say what the returned 'more detailed information' contains or how the insight is selected.

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, front-loaded sentence with no filler. Every phrase contributes: operation, resource, and source context.

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

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

With readOnlyHint, a complete schema, and a clear purpose, the description is mostly sufficient. The main gap is not describing output shape, and it relies on the trace context to imply the prerequisite workflow.

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 100% parameter descriptions, so the baseline applies. The description broadly reinforces the insight-set context but doesn't add detail beyond the schema's pageId/insightName/insightSetId explanations.

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 ('Provides more detailed information') and identifies the resource ('specific Performance Insight' within an insight set from trace recording). It clearly states what the tool does, though it doesn't contrast with sibling performance 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?

It implies the tool is used after a trace recording has produced highlighted insights, and the insightSetId parameter instructs to use IDs from the 'Available insight sets' list. No explicit when-to-use/when-not-to-use guidance or alternatives are given.

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

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

Annotations only say readOnlyHint=false, so the description carries the behavioral burden. It states that a trace will be started, but does not disclose side effects such as page reload behavior, whether an existing file may be overwritten, that the trace runs until stopped, or what the tool returns. With no output schema, the agent is left with meaningful operational uncertainty.

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 succinct sentences with no filler. The action is front-loaded in the first sentence, and the second sentence adds useful application context. Every sentence earns its place.

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

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

The input schema richly documents all parameters and even notes the navigate_page prerequisite for reload/autoStop. However, the tool-level description is incomplete for a state-changing tool with no output schema: it does not mention the trace lifecycle, how results are returned or stored, or that the trace should be stopped or analyzed via sibling tools.

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

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

Schema description coverage is 100%, and the parameter descriptions already explain pageId, reload, autoStop, and filePath. The tool description adds no parameter-level meaning beyond that, so the baseline score applies.

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

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

The description opens with a specific verb and resource: 'Start a performance trace on the target webpage.' It also names the intended outcome: finding frontend performance issues, Core Web Vitals, and improving load speed. It is not tautological, though it does not explicitly differentiate itself from sibling tools like lighthouse_audit or performance_analyze_insight.

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

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

The description gives clear context for when to use the tool ('Use to find frontend performance issues, Core Web Vitals...'), which helps an agent decide when tracing is appropriate. It does not provide explicit when-not-to-use guidance or name alternatives, but the use case is concrete enough.

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

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

Annotations include readOnlyHint=false, which correctly indicates this is a mutating/state-changing operation (stopping a recording). The description adds the behavioral context that it stops an 'active' recording, implying it may fail or no-op if no trace is active. However, it doesn't disclose what happens to the collected data, whether it must be saved via filePath, or any side effects on the page. With annotations present, the bar is lower, and the description adds some context beyond the annotation.

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

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

The description is a single, concise sentence that front-loads the action and target. It earns its place with no wasted words. It could add a note about filePath or prerequisites, but for its length it is 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?

For a simple stop operation with one required parameter and full schema coverage, the description is mostly complete. However, it doesn't clarify the relationship with performance_start_trace (e.g., must a trace be active?), nor what happens if no trace is active, nor whether filePath is required to persist the trace. The output schema is absent, so the description could have explained what the tool returns, but for a stop action this is a minor gap.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description doesn't add meaning beyond the schema, but the schema itself is clear: pageId targets a page, filePath specifies where to save trace data. The description's mention of 'trace recording' implies filePath is for saving the trace, but it doesn't clarify whether filePath is required to save data or optional. Baseline 3 is appropriate given full schema coverage.

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

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

The description clearly states the action ('Stop the active performance trace recording') and the target ('on the target webpage'). It distinguishes itself from performance_start_trace by the verb 'stop' vs 'start', though it doesn't explicitly name the sibling. The resource is clear enough for an agent to understand the tool's 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?

The description implies usage: it should be used when a performance trace is active and needs to be stopped. It doesn't explicitly state when to use it vs alternatives, but the sibling context (performance_start_trace) makes the pairing obvious. No explicit exclusions or prerequisites are mentioned, such as needing to have started a trace first.

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 only readOnlyHint=false in annotations, the description carries the burden of behavioral disclosure, but it only restates the basic operation ('Press a key'). It does not describe side effects, focus requirements, whether navigation is triggered, or what happens when a shortcut is invalid. This adds little beyond the tool name and annotation.

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

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

The description is two concise sentences with no filler. It front-loads the core action, then immediately provides selection guidance and examples, making it easy for an agent to parse quickly.

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

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

The tool is relatively simple and the schema covers all parameters, but the description omits any information about response behavior, failure modes, or prerequisites such as page focus. Since there is no output schema, a brief note about the response would improve completeness.

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

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

Schema description coverage is 100%, so the input schema already documents all parameters, including key syntax and pageId. The description adds no parameter-specific meaning beyond the usage context, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('Press') with a clear resource ('a key or key combination') and distinguishes the tool from alternative input methods like fill(). The examples of keyboard shortcuts, navigation keys, and special key combinations make the tool's purpose unmistakable even among many 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?

The description explicitly states when to use this tool: when other input methods like fill() cannot be used, and gives concrete examples. It does not explicitly enumerate exclusions or name other sibling input tools like click or type_text, but the guidance is clear enough to route an agent correctly.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, destructiveHint=false. The description adds significant behavioral context beyond annotations: Jev picks one element/action per step in ~300ms, no page text enters context, Jev never types free text (only names of values are shown), stops before irreversible actions unless allow_irreversible is set, acts on currently selected page, and returns page_id. This is rich behavioral disclosure. It doesn't contradict annotations. Minor gap: doesn't explicitly state that the walk is recorded for follow-up tools in terms of what happens if the page changes, but it does say 'the walk is recorded for them.'

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

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

The description is a single dense paragraph, but it is front-loaded with the core purpose and then covers key behavioral constraints. Every sentence adds information: purpose, mechanism, follow-up tools, typing behavior, irreversible stops, page selection, return value. It's slightly long but each sentence earns its place. It could be broken into shorter sentences for readability, but it's not bloated. A 4 because it's efficient but a bit dense.

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

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

Given the tool's complexity (8 params, nested objects, no output schema), the description is quite complete. It explains the return value (page_id) and how to use it in follow-up calls, which is essential since there's no output schema. It covers the key behavioral constraints (irreversible actions, typing limits, page selection). It doesn't describe error cases or what happens if the goal is unreachable, but the schema's max_steps and timeout_ms parameters imply those limits. The description is complete enough for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all 8 parameters. The description adds meaning beyond the schema: it explains the 'values' parameter semantics (only names reach Jev, not the actual strings), which is critical for privacy/context. It also clarifies 'goal' should describe the end state ('Say what should be visible at the end'). It explains 'url' can be omitted to start from current page. It doesn't add much for max_steps, settle_ms, timeout_ms, tab_url_prefix, allow_irreversible, but the schema already covers those well. Baseline 3 plus the values/goal/url clarifications justify a 4.

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

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

The description clearly states the tool's purpose: 'Get the browser to the exact place where you want to look, in one call.' It uses a specific verb ('get the browser to'), names the resource (browser/page), and explains the mechanism (Jev decision model). It distinguishes itself from siblings by explicitly listing follow-up tools like take_snapshot and take_screenshot, and by noting it acts on the currently selected page, differentiating it from navigation tools like navigate_page.

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

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

The description provides explicit when-to-use guidance: use this to reach a state in one call, then call list_console_messages, list_network_requests, take_snapshot, or take_screenshot on the same tab. It also gives clear exclusions: 'Stops before orders, payments, sends, deletes, and publishes unless allow_irreversible is set.' This tells the agent when not to use it or what to set. It also explains the alternative of omitting url to start from the current page, and how to pass values for typing, which is a key usage distinction from type_text.

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

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

Annotations provide `readOnlyHint: false`, signaling this is not a read-only operation, and the description adds the outcome of resizing the window. However, it does not disclose side effects such as whether the page reloads, whether the viewport or the outer browser window is affected, or whether dimensions are in pixels. This adds some context but not rich behavioral detail.

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

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

The description is a single sentence with no filler and gets to the point immediately. Minor awkwardness in 'page's window' and the slightly redundant phrasing cost it the top score.

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

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

For a simple three-parameter tool, the description is mostly sufficient: it names the action, target, and dimensions. Still, an agent would still need to assume units or infer from sibling context, since there is no mention of output, exact dimension semantics, or post-conditions beyond the minimal 'page has specified dimension'.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's 'specified dimension' maps to `width` and `height`, but it adds no units, constraints, or relationship between the parameters beyond what the schema already states.

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

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

The description clearly states a specific action ('Resizes') and a specific target ('the page's window') with named dimensions. It is unambiguous against most sibling actions, but it does not explicitly differentiate itself from dimension-related tools like `emulate`, so it stops short of a 5.

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

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

The description gives no guidance on when to use this tool versus alternatives such as `emulate`, `select_page`, or `navigate_page`. There is no mention of prerequisites, context, or exclusions, so the agent must infer intended usage purely from the tool name.

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

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

The readOnlyHint annotation already signals no data mutation, so the description's main job is to disclose the stateful selection effect, which it does by saying the page becomes context for future calls. It does not mention persistence or clearing behavior, but the key behavioral trait is present and does not contradict the annotation.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to explaining the tool's purpose and timing.

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 two-parameter, read-only selection tool, the description plus schema covers the essential agent workflow: what to select, how to find the ID, and what the selection affects. It could mention whether the selected context persists or is replaced, but that is a minor gap for this tool.

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

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

Schema description coverage is 100%, so the baseline is 3 and the description does not need to carry parameter documentation. The pageId parameter description adds useful guidance ('Call list_pages to get available pages'), but that lives in the schema rather than the tool description itself.

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 names a specific verb and resource: selecting a page to act as context for future tool calls. It is clearly distinguishable from sibling tools like list_pages or close_page, though it does not explicitly contrast itself with them.

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

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

It explicitly frames the tool as a setup step—'context for future tool calls'—which tells an agent when to invoke it. The pageId parameter also gives a concrete prerequisite by directing the agent to call list_pages for available pages, though the main description does not state when not to use it.

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

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

Annotations only provide readOnlyHint=false, so the description carries some burden. It implies a side effect by 'capture' and the filePath schema field, but does not state whether existing files are overwritten, whether the page is paused, or how large the snapshot can be. It does not contradict the readOnlyHint=false annotation.

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

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

Two sentences front-load the action ('Capture a heap snapshot...') and then give the purpose. There is no redundancy or extraneous information.

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

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

Given only two required parameters, full schema coverage, and no output schema, the description covers the core invocation context. It could mention what happens after the snapshot is saved, but that is a minor gap for a low-complexity tool.

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

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

Schema description coverage is 100%, so the schema already documents pageId and filePath. The description adds no specific parameter guidance beyond the general memory-analysis purpose. Baseline 3 is appropriate.

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

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

Description names a specific action and object: 'Capture a heap snapshot of the target page.' It also clarifies the domain (JavaScript memory distribution), which helps distinguish it from sibling tools like take_snapshot and evaluate_script. It does not explicitly contrast with siblings, so it is clear but not fully differentiated.

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 second sentence states an explicit intended use case: analyze memory distribution of JavaScript objects and debug memory leaks. This gives the agent clear context for when to choose this tool, though it stops short of naming alternatives or when-not-to-use conditions. It is above merely implied 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?

The description only states the core action and target, adding little beyond the annotations. It does not disclose behavior such as whether the screenshot is attached to the response or saved to a file when filePath is provided, nor does it mention fullPage incompatibilities. These are left to the schema, not the description.

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

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

The description is a single concise sentence with no wasted words, making it easy to parse. It is not structured with additional details, but for a simple tool this brevity is appropriate and front-loads the primary 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?

The schema is rich and describes all six parameters clearly, which compensates for the minimal description. However, there is no mention of what the tool returns or how screenshots are delivered when filePath is not used, and no guidance on element vs page screenshot distinctions. This leaves some gaps, but the schema covers most operational details.

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

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

Schema description coverage is 100%, so the schema already thoroughly documents each parameter. The description adds no additional meaning about parameters; it merely mentions 'page or element,' which is already reflected in the pageId and uid parameter descriptions. A baseline 3 is appropriate since the schema carries the semantic load.

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

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

The description clearly identifies the operation ('Take a screenshot') and the target ('the page or element'), which is specific and understandable. However, it does not differentiate itself from sibling tools like take_snapshot or take_heapsnapshot, so an agent might not know which capture tool to select without more context.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. There is no reference to performance traces, snapshots, or other capture mechanisms, so the agent is left without context for choosing this specific tool.

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

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

The description adds behavioral context beyond the annotations: it explains the snapshot is based on the a11y tree, lists elements with uids, and indicates the selected element in DevTools. The annotation readOnlyHint=false is consistent with the description (it's a read operation but not marked read-only, likely because it may have side effects like saving to a file). The description doesn't contradict the annotation. It could mention side effects of saving to filePath, but the schema already covers that parameter.

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

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

The description is three sentences, each earning its place: what it does, when to use it, and what it indicates. It's front-loaded with the core function and includes actionable guidance without fluff.

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

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

The description is complete for a snapshot tool: it explains the output format (text snapshot, a11y tree, uids), usage preference over screenshots, and the DevTools selection indicator. It doesn't describe the return format in detail, but there's no output schema and the description gives enough for an agent to understand what to expect. Minor gap: it doesn't explain what 'verbose' does beyond the schema, but the schema already covers that.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (pageId, verbose, filePath). The description adds context about the snapshot content (a11y tree, uids) but doesn't add parameter-specific meaning beyond what the schema provides. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the tool's function: taking a text snapshot of the target page based on the a11y tree, listing elements with unique identifiers. It also explicitly differentiates from the sibling tool take_screenshot by saying 'Prefer taking a snapshot over taking a screenshot.' This makes the purpose unambiguous and distinguishes it from similar tools.

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

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

The description provides explicit usage guidance: 'Always use the latest snapshot' and 'Prefer taking a snapshot over taking a screenshot.' This tells the agent when to use this tool and implies when not to use it (when a screenshot is needed). It also mentions the snapshot indicates the element selected in the DevTools Elements panel, which is useful context for interpreting results.

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

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

Annotations already indicate readOnlyHint=false, so the write nature is known. The description adds that it simulates keyboard input and requires focus, but does not disclose behaviors like whether it replaces existing content, triggers events, or handles auto-submit. This is minimal added value beyond annotations.

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

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

A single sentence with no redundancy, front-loading the core action and its key condition. 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 typing tool with full schema coverage and a clear prerequisite, the description covers essential aspects. It might benefit from noting that the target must be an input element, but this is implied by 'input'. Adequate 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?

Schema coverage is 100%, with clear descriptions for text, pageId, and submitKey. The description does not add new meaning about parameters, only reinforces the focus requirement indirectly. Baseline of 3 is appropriate.

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

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

The description clearly states the verb 'type text', the resource 'keyboard into a previously focused input', and the prerequisite that the input must already be focused. This distinguishes it from siblings like fill or press_key, even without naming them.

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

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

It explicitly mentions the prerequisite of a previously focused input, guiding when to use it. However, it does not name alternatives or state when not to use it (e.g., for complex forms, fill_form might be more appropriate).

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

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

With only readOnlyHint=false and no description-level detail, the agent gets no information about side effects, whether a file chooser may open, or how multiple files are handled. 'Upload a file through a provided element' states the action but adds no behavioral context beyond the annotation.

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

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

The description is a single, front-loaded sentence with no filler. It is concise, though arguably too spare to be maximally useful.

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

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

This is a mutating browser-automation tool with four parameters and no output schema, but the description leaves the workflow (element targeting, local path requirement, snapshot behavior) to the schema. Some of that is in the schema, yet the overall tool context is under-specified for an agent deciding whether to invoke it.

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

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

Schema coverage is 100%, so the schema already documents uid, pageId, filePaths, and includeSnapshot. The description's 'provided element' maps weakly to uid, but it does not add meaning beyond what the schema gives.

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 names a specific verb ('upload') and resource ('a provided element'), which differentiates it from sibling actions like click or fill. It doesn't explicitly contrast with siblings, but the action is clear.

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

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

No guidance is given about when upload_file should be used instead of fill, fill_form, or type_text, nor when a file input vs. file-chooser element is appropriate. The phrase 'provided element' is implied context, not explicit usage direction.

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

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

Annotations declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds the behavior of waiting for text appearance, but doesn't disclose details like polling behavior, what happens on timeout, or whether it resolves on any match vs all matches. The schema's text description says 'Resolves when any value appears' which covers the any-match behavior, so the description adds minimal extra behavioral context beyond the annotation.

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

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

The description is a single, clear sentence that front-loads the core action. It's concise and to the point, with no wasted words. It could arguably include a bit more context, but for its length it's 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?

The tool has 3 parameters, all documented in the schema, and a readOnlyHint annotation. The description is minimal but sufficient for a simple wait operation. However, it doesn't mention timeout behavior (e.g., what happens if text never appears) or whether the wait is for any text vs all texts, though the schema partially covers the 'any' behavior. For a tool with no output schema, a bit more context on return behavior would be 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 description coverage is 100%, so the schema already documents all three parameters. The description adds no additional parameter semantics beyond what the schema provides. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states a specific verb ('wait for') and resource ('specified text' on 'selected page'), which clearly distinguishes it from sibling tools like click, fill, or navigate_page. It doesn't explicitly name a sibling alternative, but the action is unambiguous.

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

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

The description implies usage context: use it when you need to wait for text to appear. It doesn't explicitly state when not to use it or mention alternatives like wait_for vs reach (which might be a sibling for scrolling/waiting). The context is clear enough for an agent to infer, but no explicit guidance is given.

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