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

With no annotations, the description must carry the behavioral load. It usefully discloses the execution timing (before page scripts) and the persistence scope (every new document), which are the two traits that matter most here. It omits whether the script persists across browser restarts, whether it applies to already-open tabs, and that browser_remove_preload_script is required to undo it.

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

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

A single sentence that front-loads the action and its timing, with the analogy parenthetical earning its place. Nothing is redundant or padded.

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 no output schema, the description covers the essentials: what is injected, when it runs, and the mental model for it. It is nearly complete; persistence semantics across sessions and the removal path are the remaining gaps.

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

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

Only one parameter ('source') and schema description coverage is 100%, so the schema already documents the argument fully. The description adds only the framing word 'custom JavaScript', which is marginal value beyond the schema's 'JavaScript source code to evaluate'.

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?

States a specific verb ('Inject') plus resource ('custom JavaScript') and the critical timing constraint ('on every new document before page scripts load'). It clearly reads as distinct from browser_eval, which executes on demand in the current context. It does not name browser_remove_preload_script as the inverse, but the purpose itself 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 parenthetical '(hooks / Tampermonkey)' implies the use case (persistent instrumentation of future documents), which is decent implied guidance. However, it gives no explicit when-not guidance or alternatives — e.g., that browser_eval should be used for one-off evaluation rather than persistent injection.

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

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

No annotations are provided, so the description carries the full burden. It states the action but omits behavioral details such as side effects, error handling when history is empty, whether navigation waits for page load, or any permissions. It adds little beyond the tool name.

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

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

A single, front-loaded sentence with no wasted words. It is appropriately sized for the simple action, though its brevity contributes to missing behavioral context (captured elsewhere).

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

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

The tool has no annotations and no output schema, and the description does not explain return values or failure modes. For a simple back-navigation action with one fully documented parameter, the description is adequate but leaves behavioral gaps that no other structured field fills.

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

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

Schema description coverage is 100%: the single parameter 'delta' is documented with type, default, and meaning ('Number of steps backward'). The description adds no parameter information, but since the schema covers it fully, 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?

States a specific verb ('Navigate backward') and resource ('browser history'), with a parenthetical 'back button' clarification. It distinguishes itself from browser_forward by direction, but does not name sibling tools or add scope beyond the direction. Clear enough that an agent can select it for going back.

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

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

Gives no explicit guidance on when to use this tool versus browser_forward, browser_history, or browser_navigate. Usage is only implied by the direction 'backward'. No prerequisites or exclusions are provided.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only claims speed and enumerates actions. It never states whether steps execute sequentially, what happens on a mid-sequence failure (abort vs continue), whether state persists between steps, or what the tool returns. For a 39-action batch executor these are critical omissions.

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?

Purpose is front-loaded before the action list, which is content-bearing rather than padding. However, the ALL-CAPS marketing headline ('ULTRA-FAST', 'without model latency') costs space without informing invocation, and the list is delivered as one undifferentiated run-on.

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 whose whole value is orchestrating many chained actions, the description omits ordering guarantees, failure/rollback semantics, and return shape, and there is no output schema to compensate. Given no annotations and a 19-field nested step object, this is under-specified for correct invocation.

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

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

The schema has no enum on the 'action' field (parameters with enums: 0), so the description's list of 39 valid action strings is genuinely additive vocabulary unavailable in the schema. It also flags 'screenshot' modifiers (full_page, clip selector). It stops short of mapping which step fields (ref/url/selector/text/key) belong to which action, leaving per-step usage to inference.

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?

States a specific verb+resource ('Execute a sequence of browser actions') with an explicit distinguishing scope: one round-trip instead of many. The exhaustive action list makes it unambiguous against every single-action sibling (browser_click, browser_navigate, browser_screenshot, ...).

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 phrase 'in a single round-trip without model latency' implies when to use it (multi-step workflows where per-step round-trips are costly), but no alternative is named and no when-not condition is given. An agent must infer that single actions should use the dedicated sibling tools.

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

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

With no annotations provided, the description carries the full behavioral burden. It reveals nothing about scope (current tab vs. all tabs), persistence across navigations, whether blocking is reversible, or how it interacts with existing blocks — all critical for a filtering/mutation tool.

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

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

A single well-formed sentence that front-loads the action, lists the targets, and ends with the payoff. Every clause 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 5-parameter, zero-required tool with no annotations and no output schema, the description covers what is blocked but omits scope and persistence details the agent needs to invoke it correctly. It is adequate but leaves meaningful gaps.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description restates the same categories (images, media, fonts, trackers) without adding format or default semantics beyond the schema, 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 gives a clear verb ('Block') and enumerates the resource categories plus custom URLs, so the agent knows exactly what the tool affects. It does not, however, distinguish itself from the sibling browser_block_urls, which likely overlaps in 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?

It states the benefit (accelerated page load) but gives no explicit when-to-use, when-not-to-use, or prerequisite context, and never mentions the closely related browser_block_urls sibling. The agent must infer when this is preferable to that alternative.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it omits key traits: whether blocked patterns persist across navigations or tabs, whether they can be unblocked, how glob matching works, and what happens to already-loaded requests. It only conveys the intent of the blocking, not its mechanics or side effects.

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

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

A single front-loaded sentence with no filler; the purpose and examples come before the rationale. It is appropriately sized for a one-parameter tool, though it leaves behavior unexplained.

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 no annotations or output schema, the description covers what the tool does and the pattern syntax needed to call it correctly. It is incomplete on lifecycle/scope questions (persistence, per-tab vs. global) that matter for a browser-mutating operation.

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

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

Schema description coverage is 100% ("Wildcard URL patterns to block"), so the schema already documents the single parameter. The inline examples in the description ("*.png, *analytics*, *ads*") usefully clarify the wildcard format, but add only marginal value beyond the schema.

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

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

The description states a specific action (block) on a specific resource (URL patterns) and even illustrates the pattern syntax with examples like *.png and *analytics*. It does not, however, distinguish itself from the sibling browser_block_resources, which is the most likely tool an agent could confuse it with.

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?

Usage is implied by the stated goal ("to speed up page loading"), which tells the agent roughly when this tool is relevant. There is no explicit guidance on when to prefer this over browser_block_resources or browser_set_headers, and no scoping conditions 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?

No annotations are provided, so the description carries the full burden. It communicates that commands are raw and includes a timeout, but does not disclose side effects, permission requirements, reversibility, error behavior, or that powerful commands like 'Fetch.enable' or 'Tracing.start' can alter browser state. It lacks the concrete behavioral context needed for a raw protocol passthrough.

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

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

The description is a single front-loaded sentence with no wasted sentences, and the core capability is stated first. 'GOD MODE' is informal branding that adds little informational value, keeping it from a perfect 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 high-complexity universal tool with nested params, no output schema, and no annotations, the description is adequate but thin. It does not explain how to discover valid CDP methods, what happens on invalid commands, or what the response looks like, leaving significant gaps for an agent invoking raw protocol calls.

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 method, params, and timeout. The description adds examples of valid method values, but these overlap with the schema's own examples and do not clarify params structure or timeout tradeoffs beyond what is structured.

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 (Send) and resource (raw Chrome DevTools Protocol command) with explicit scope (any, directly with custom parameters). It distinguishes itself from siblings by positioning as a universal escape hatch, giving examples like 'DOM.getBoxModel' and 'Fetch.enable' that no other listed tool covers.

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 phrase 'UNIVERSAL RAW CDP (GOD MODE)' implies this is the fallback for arbitrary CDP commands not exposed by dedicated browser_* tools, but there is no explicit when-to-use or when-not-to-use guidance, and no sibling is named as an alternative. Usage is implied rather than stated.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that tabs are closed (a destructive, non-reversible action) and the categories targeted, but leaves the notion of 'stale' undefined even though no parameter controls staleness, and does not describe the return value or what the agent learns about what was closed.

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 well-formed sentence that front-loads the action and the target categories with zero filler. Nothing is repeated and nothing is wasted.

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?

Relatively simple tool: no output schema, no annotations, three optional parameters all documented in schema. Wait – the description omits the keep_current default behavior and the undefined staleness criterion, so it is not fully complete: score 3.

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 only marginal detail beyond the schema ('about:blank' as an example of blank, and 'pattern-matching' for url_patterns), but the schema already documents all three parameters cleanly.

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?

States a specific verb (close) and resource (tabs) with clear scope qualifiers: stale, blank (about:blank), and pattern-matching. This implicitly separates it from the singular browser_close_tab sibling, though it never names that sibling explicitly.

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 purpose implies bulk cleanup usage, but there is no explicit guidance on when to use this versus browser_close_tab or browser_list_tabs, and no mention of prerequisites or when cleanup should be avoided. Usage must be inferred.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the destructive targets (cache and cookies), which is the key effect an agent needs, but omits scope (per-tab vs global), reversibility, session-logout implications, and whether a reload occurs.

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

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

A single short sentence that front-loads the action and its targets. It is efficient, though it is arguably under-specified rather than genuinely tight.

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 destructive tool with no annotations, no output schema, and zero parameter description coverage, the definition is too thin. An agent lacks information about scope, side effects on the active session, and the semantics of the two flags.

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

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

Schema description coverage is 0% for both booleans, so the schema adds no meaning. The description's "cache and/or cookies" phrasing does map onto clear_cache and clear_cookies and implies they are independently combinable, but it never explains the default-true behavior or what passing only one flag does.

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 gives a specific verb ("Clear") and resource ("browser cache and/or cookies"), which an agent can immediately distinguish from the read-oriented siblings like browser_get_storage or browser_get_cookies. It does not explicitly name a sibling or scope, 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?

There is no guidance on when to use this tool versus alternatives such as browser_set_cookie or browser_get_storage, nor any prerequisites or exclusions. The agent must infer all 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?

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether clicking waits for the element, scrolls it into view, fails when the target is missing, or what side effects or return values to expect.

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

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

A single efficient sentence that front-loads the action and immediately lists the two accepted targeting methods. There is no wasted text.

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

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

For a simple two-parameter click tool with no output schema, the description covers the essential invocation inputs. However, with no annotations it omits behavioral context such as snapshot prerequisites, element visibility requirements, and error handling that an agent may need.

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 restates the same targeting syntax without adding format details, fallback behavior between ref and selector, or constraints 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?

States a specific verb (Click) and resource (element) plus the two targeting mechanisms (snapshot ref or CSS selector). However, it does not distinguish this action from sibling tools like browser_fill or browser_press_key, so sibling differentiation is absent.

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

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

No explicit guidance on when to use browser_click versus alternatives such as browser_fill, browser_press_key, or browser_mouse. The phrase 'snapshot reference' implies a prerequisite relationship with browser_snapshot but does not state it or clarify exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It signals that a write mode exists (implying clipboard mutation/overwrite) but says nothing about permissions, whether the prior clipboard contents are lost on write, or what a read returns (plain text? empty if none?).

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 efficient sentence with no filler and the core purpose front-loaded. It is appropriately sized, though brevity here edges toward under-specification rather than tightness.

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 a mutating mode, zero annotations, no output schema, and only 50% parameter coverage, the description is too thin. An agent has no information about return values, failure modes, or the effect of a write on existing clipboard content.

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 50%: 'text' is described in the schema, but 'action' has an enum with no description. The description's phrase 'read or write' loosely maps to the action values, but it adds no format, default, or return-syntax meaning beyond what the schema already shows. Baseline 3 for a partially documented two-parameter tool.

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

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

The description states a specific verb pair (read/write) and a specific resource (system clipboard), which is enough for an agent to understand the tool's function. It does not need sibling differentiation because no other tool in the list touches the clipboard, but it also does not mention the default mode or dual nature in any operative way.

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 choose read vs write, no mention that 'action' defaults to 'read', and no prerequisites or alternatives named. The agent must infer the mode selection entirely from the 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses the default-target behavior, but for an inherently destructive operation it does not say the close is irreversible, whether unsaved state is lost, or what happens to dependent tabs.

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 zero wasted words that covers both the explicit and default modes of invocation.

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, no-output-schema tool this is nearly complete: purpose and both invocation paths are covered. The only omission is the destructive/irreversible nature of closing a tab, which annotations do not supply either.

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

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

Schema coverage is 100%, so the baseline is 3, and the description genuinely adds meaning beyond the schema's terse 'Target ID to close (optional)' by explaining that omitting the ID closes the current tab. It does not specify ID format or how to obtain one, which is a minor gap.

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

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

States a specific verb and resource ('Close a browser tab') and additionally defines the default behavior when the optional ID is omitted. This distinguishes it from bulk siblings like browser_cleanup_tabs and from opening tools like browser_new_tab, though it does not name any sibling explicitly.

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

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

The description tells the agent the operative condition: pass target_id to close a specific tab, omit it to close the current tab. That is implied usage guidance, but there is no mention of when to prefer this over siblings like browser_cleanup_tabs or any prerequisite such as the tab being active.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses what is captured (console.log/error/warn, unhandled exceptions) and the word 'captured' implies logs must already be collected, but it says nothing about retention, whether logs are cleared between calls, or ordering.

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 zero filler, front-loading the resource and immediately qualifying it with the concrete log types captured. Nothing is wasted.

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?

There is no output schema, and the description does not describe the shape of returned entries (message, timestamp, stack trace, severity), so the agent cannot anticipate the response format. For a low-complexity read-only tool with full parameter coverage, this is adequate but leaves a gap.

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

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

Schema description coverage is 100%, so both parameters (limit, log_type) are fully documented in the schema. The description's mention of console.log/console.error/console.warn loosely maps to the log_type filter but adds no semantics beyond it.

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

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

States a specific verb ('View') and a precise resource ('captured JavaScript console logs' plus 'unhandled page exceptions'), and enumerates the log levels captured. It is clearly distinguishable from siblings like browser_network_requests or browser_export_traffic, though it never names an alternative explicitly.

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 when-to-use, when-not-to-use, or alternative guidance. The debugging use case is only implied by the content type; an agent must infer that this is the tool for JS errors rather than network or DOM issues.

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

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

No annotations are provided, so the description carries the full behavioral burden and largely fails. It does not say whether the emulation applies to the current page or tab, whether it persists across navigations, whether it can be reset/cleared, or if it requires permissions — all critical for a state-mutating browser tool.

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

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

A single sentence with no wasted words is well front-loaded, but here brevity is under-specification rather than economy — the sentence is too thin for a three-parameter state-setting 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?

With no annotations, no output schema, three undocumented-ish parameters, and two overlapping siblings, the definition is not complete enough for confident invocation. It should at minimum clarify scope (tab/page), reversibility, and its relationship to browser_set_geolocation/browser_set_timezone.

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 only 33%: timezone_id has an example format, but latitude and longitude are bare numbers. The description's 'coordinates and/or timezone' hints that the pairs are optional and combinable, but adds no format, range, or pairing rules beyond the schema's weak 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 gives a specific verb ('emulate') and two named resources (geolocation coordinates, timezone), so an agent knows the tool's domain. It stops short of differentiating from the near-identical siblings browser_set_geolocation and browser_set_timezone, leaving unclear whether 'emulate' combines them or duplicates 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?

There is no when-to-use guidance, no mention of prerequisites, and no routing to alternatives. Given two direct sibling tools (browser_set_geolocation, browser_set_timezone) that appear to cover the same ground, the absence of any disambiguation is a real gap.

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

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

With no annotations, the description carries the full behavioral burden. It discloses only that code runs in the page context and a result is returned, saying nothing about mutation risk (arbitrary JS can modify the DOM/storage), whether execution is sandboxed, how async/promise results are handled, or authorization requirements. For an arbitrary-code-execution tool this is a notable gap.

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

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

A single, front-loaded sentence that states the action, the execution context, and the return behavior with zero wasted words.

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

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

The description partially covers return behavior ('return the result'), which matters since no output schema exists, but for a privileged arbitrary-JS tool with no annotations it omits safety/mutation context and result-serialization details that an agent would need before invoking 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?

There is a single parameter with 100% schema description coverage, so the schema already documents 'script'. The description adds only the 'active page context' framing, which is baseline-level value; per the coverage rule, 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?

States a specific verb ('Evaluate') and resource ('arbitrary JavaScript in the active page context') plus the outcome (returns the result). This is clearly distinguishable from sibling tools like browser_click or browser_snapshot. It does not, however, name or contrast with the closest alternative, browser_cdp_send, which could also execute scripts.

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

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

No when-to-use guidance is given. The description never addresses whether to prefer this over browser_cdp_send, browser_click/browser_fill for interactions, or browser_console_logs for reading output, nor does it note prerequisites such as a loaded page.

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

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

With no annotations, the description carries the full behavioral burden. It says what is written but not whether the file is overwritten or appended, whether it requires an active capture session, whether it blocks on in-flight requests, or what permissions/filesystem restrictions apply. For a tool that writes a potentially large file to disk, these omissions leave real operational gaps.

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

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

A single front-loaded sentence with no filler; the verb comes first and the enumerated payload follows. It is well-sized, losing a point only because the terseness leaves room that no additional useful sentence fills.

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 export tool with no output schema and no annotations, the description covers the core payload adequately, but it omits prerequisites (must traffic be recorded first?), file-overwrite behavior, and how it relates to the sibling traffic-reading tools. It is minimum-viable rather than 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?

There is a single parameter with 100% schema description coverage ('Absolute or relative file path to save traffic dump'), so the schema already documents it fully. The description adds nothing about the path format beyond that, so the baseline of 3 for high coverage 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?

States a specific verb (Export) and enumerates exactly what is exported (requests, responses, headers, POST data, WebSocket frames) plus the output format (structured JSON file). It is clear on its own, but it never distinguishes itself from overlapping siblings like browser_network_requests or browser_websocket_messages, which an agent browsing this family would reasonably confuse it with.

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 phrase 'all captured' hints that traffic must be captured beforehand, but there is no explicit when-to-use, no condition for choosing this over browsing traffic via browser_network_requests, and no note on whether it should be called before or after navigation. The agent is left to infer invocation timing entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It reveals that this is a mutation tool and what actions are possible, but does not state required permissions, side effects, reversibility, or what happens when enabling, disabling, or reloading an extension.

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 lists the available actions without any wasted words. It is appropriately sized for a simple two-parameter tool.

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

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

Given the low complexity, high schema coverage, and absence of an output schema, the description is nearly complete for correct invocation. It could still add prerequisites or side-effect information, since there are no annotations to cover those behavioral 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 coverage is 100%, so both parameters are already documented in the schema. The description's action list mirrors the action enum rather than adding new meaning, which matches the baseline of 3 when the schema does the heavy lifting.

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

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

The description states a specific verb and resource: perform management actions on a Chrome extension, and enumerates the supported actions. It clearly distinguishes this tool from browser_list_extensions, though it does not explicitly name that or any other sibling tool.

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

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

The description lists the possible actions but gives no guidance on when to use this tool versus alternatives, no prerequisites, and no when-not conditions. Usage is only implied by the action list.

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

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

No annotations are supplied, so the description carries the entire behavioral burden. It does not disclose what events are dispatched, whether the element is focused first, what happens on a non-input target or a stale ref, or how failures are reported. Only the basic mutation intent is conveyed.

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 the action first and the two addressing modes second; there is no filler 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?

Four params, no nested objects, no output schema, and full schema coverage mean the structured data is largely sufficient for calling it. However, with zero annotations the description omits behavioral caveats an agent needs (ref staleness, event behavior, failure modes), leaving a real gap for a browser-mutation 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 ref, text, clear, and selector. The description merely repeats the ref/selector addressing modes with no additional format, precedence, or conflict-resolution detail (e.g., what happens if both ref and selector are given). Baseline 3 applies.

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

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

States a specific verb (fill) and resource (text into an input element) plus the two addressing modes, which separates it from siblings like browser_click or browser_press_key. It does not explicitly name a sibling or contrast itself with one, 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 implies when to use it (to enter text into an input) and offers two addressing options (snapshot ref vs CSS selector), but gives no explicit when-to-use/when-not-to-use guidance or prerequisites (e.g., element must be an input, page must be loaded, snapshot freshness). Usage is only implied.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose three concrete actions: counting matches, extracting context snippets, and scrolling to the first match. It stops short of describing edge behavior such as case sensitivity, zero-match handling, or the shape of returned snippets.

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

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

A single sentence that front-loads the core purpose and packs the three behaviors with zero filler. Every clause 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 two-parameter tool with no output schema or annotations, the description covers purpose and the main observable behaviors (count, snippets, scroll), which effectively hints at return content. Minor gap: no mention of no-match or case-handling behavior.

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 parameters are already documented. The description's 'scroll to first match' maps to scroll_to_first but adds no syntax, defaults, or meaning beyond the schema, making the baseline 3 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?

States a specific verb+resource ('Find text on page') and the Ctrl+F analogy anchors it instantly. No sibling in the list performs in-page text search, so it is unambiguously distinct from navigate, snapshot, or get_html.

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

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

The Ctrl+F analogy clearly conveys the usage context (searching the currently loaded page) with no need to name alternatives since none exist. However it offers no explicit when/when-not framing, e.g. that it operates on the current tab's rendered DOM rather than source.

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

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

No annotations are provided, so the description carries the full burden. It says nothing about what happens when there is no forward history, whether the call errors or is a no-op, or whether it waits for the page to load — all meaningful behaviors for an agent orchestrating browser navigation.

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

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

A single short sentence with the action front-loaded and no filler. It is efficient, though almost to the point of under-specifying 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 trivial one-parameter navigation tool with no output schema, the description is minimally adequate to invoke it. However, with no annotations and no statement of failure/no-op behavior, an agent lacks enough context to handle edge cases confidently.

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

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

Schema description coverage is 100% and the single optional 'delta' parameter is documented as 'Number of steps forward' with a default of 1. The description adds no extra meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (navigate) and resource (browser history, forward direction), and the parenthetical '(forward button)' anchors it to a familiar UI action. It is clearly distinguishable from the sibling browser_back, though it never names that sibling or otherwise contrasts itself explicitly.

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 versus browser_back, browser_history, or browser_navigate, all of which live adjacent in the tool list. A caller must infer the intended context entirely 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?

With no annotations, the description carries the full burden. It discloses that ALL cookies are returned (no filtering) and that scope is the current tab, but says nothing about return format, whether httpOnly/session cookies are included, or any security/permission implications.

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 zero filler; the action, scope, and payload type are all conveyed economically.

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 trivial zero-parameter read tool this is close to adequate, but with no annotations and no output schema the description leaves the return structure and any scope caveats implicit, which an agent would need to discover at call time.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate. It adds no parameter detail, but none is needed.

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

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

States a specific verb (Retrieve) and resource (cookies) with an explicit scope (current tab), and the parenthetical examples (auth tokens, session IDs) clarify the payload. It is easily distinguished from the write-side sibling browser_set_cookie, though it does not explicitly contrast with browser_get_storage.

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

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

No when-to-use or when-not-to-use guidance is provided. The agent must infer that this reads cookies for the active tab and cannot tell from the description how it differs from browser_get_storage or browser_clear_storage, nor whether any prerequisite (e.g., a selected tab) is required.

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

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

With no annotations provided, the description carries the full behavioral burden. 'Inspect' implies a non-mutating read, but nothing states whether it requires a loaded page, what happens if the selector matches nothing, or whether it forces style recalculation. Key behavioral context is absent.

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

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

A single front-loaded sentence with no filler: the capability comes first and the input modes follow. Nothing could be trimmed without losing meaning.

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 an inspection tool with no output schema, describing the return as 'computed styles and matched stylesheet rules' is a reasonable start, but the shape of that data (per-property values, which rule won, cascade info) is left undefined, and with no annotations the tool's safety/state profile is also unstated.

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 params are already documented, and the baseline is 3. The description does add a small amount of value by framing ref and selector as alternative lookup modes rather than two independent inputs, but it adds no format details beyond the schema's '@1' example.

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 (inspect) and a precise resource (computed CSS styles and matched stylesheet rules), and it clarifies the two lookup modes. No sibling tool covers this exact capability, so an agent can place it confidently, though it never names or contrasts an adjacent tool.

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

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

There is no when-to-use guidance, no prerequisites (e.g. page must be loaded, element must come from a prior snapshot), and no indication of when to prefer browser_eval or browser_get_html instead. The 'by selector or @ref' clause is input selection, not usage guidance.

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

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

With no annotations, the description carries the full burden, but it does convey the key behavioral trait: it extracts the full outerHTML rather than a summary or serialized tree, and it can write to a file instead of returning content. It omits side-effect profile, return type, and any handling of very large documents, so the behavioral picture is incomplete for a no-annotation tool.

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

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

A single efficient sentence with the primary behavior front-loaded before the optional save mode. Nothing is wasted, though the terseness contributes to the coverage gaps noted elsewhere.

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

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

For a simple, no-required-parameter read tool this covers the essentials, but with no output schema and no annotations an agent still lacks confirmation of return type (string vs file path), behavior on large pages, and when this beats browser_snapshot.

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

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

Schema coverage is 100% and the single parameter already documents 'Optional file path to save HTML'. The description's 'or save to file' phrase reinforces that mode but adds no syntax, path format, or overwrite semantics 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?

States a specific verb ('Extract') and resource ('full outerHTML of the entire document'), which clearly distinguishes it from a rendered screenshot or accessibility snapshot. It does not name which sibling to prefer over it (e.g. browser_snapshot or browser_eval), so it stops short of full sibling differentiation.

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

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

The description mentions the two output modes (return HTML or save to file) but gives no guidance on when to use this tool versus browser_snapshot, browser_eval, or browser_find_in_page. No prerequisite or context conditions are stated, leaving selection entirely 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?

No annotations are provided, so the description carries the full burden. 'Inspect' implies a read-only operation, but nothing is said about whether the returned data is a summary or full contents, whether databases are lazily opened, or any side effects. For a zero-param tool with no annotation coverage this is thin.

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 tight sentence with the scope constraint front-loaded; every word earns its place and there is no filler.

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

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

For a simple zero-parameter read tool this is close to adequate, but with no output schema and no annotations the description does not say what is returned (database names? store names? record counts?) or any caveats about origin/tab context.

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

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

The tool takes zero parameters, so the baseline is 4. The description's 'for current origin' at least clarifies the implicit scope that replaces a parameter, adding a small amount of meaning.

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

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

States a specific verb (Inspect) and resource (IndexedDB databases and object stores), scoped to 'current origin'. That is enough to separate it from browser_get_storage and browser_get_cookies in spirit, though it never explicitly names or contrasts those siblings.

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

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

There is no when-to-use guidance, no prerequisites (e.g. page must be loaded / origin context), and no mention of alternatives such as browser_get_storage or browser_eval. The origin scoping is the only contextual hint, which is not usage guidance.

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

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

With no annotations, the description carries the full burden. It does disclose scope (both storage types, all items, current origin), and 'inspect' strongly implies a read-only, non-destructive operation. However it says nothing about value truncation, size limits, or whether sensitive values are returned verbatim.

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 word contributes to identifying what is dumped and where it comes from.

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

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

For a simple no-param read tool with no annotations and no output schema, the description covers what is read but not the shape of the dump (key/value pairs, counts, ordering) or any failure mode when no origin/page is active. Adequate but leaves a gap.

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

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

The tool takes zero parameters, so the baseline is 4. The description's 'for the current origin' scoping is the only semantic note needed and it is present.

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?

States a specific verb (inspect/dump) plus the exact resources (localStorage and sessionStorage) and scope (current origin). This clearly separates it from browser_get_cookies and browser_get_indexeddb, though it never names those siblings explicitly.

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

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

There is no guidance on when to use this tool versus alternatives such as browser_get_cookies, browser_get_indexeddb, or browser_eval, nor any prerequisites (e.g., needing an active page/origin). The agent must infer usage purely from the resource name.

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

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

With no annotations, the description carries the full behavioral burden, and it discloses nothing about persistence (session vs profile), whether grants survive navigation, or whether reset wipes all permissions or only those for the origin. For a state-mutating permission tool this is a significant gap.

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

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

A single front-loaded sentence with the action and scope first and no filler. It is efficient, though it could carry one more clause of behavioral context at the same length.

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

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

Given three optional parameters, no output schema, and zero annotation coverage, the definition is only minimally adequate. It explains intent but leaves the reset semantics and the return/state behavior for an agent to infer.

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 three parameters are already documented, and the description's permission examples merely echo the schema's own examples. Baseline 3 applies since the description adds no syntax or format detail beyond the structured fields.

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 pair (grant/reset) and resource (browser permissions) scoped to an origin, which separates it from generic browser tools. It does not explicitly name a sibling to contrast with, 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?

It says what the tool does but never when to reach for it over neighbors like browser_set_geolocation or browser_clipboard, nor does it explain the grant-vs-reset choice beyond the parameter name. No prerequisites or exclusions 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?

With no annotations, the description carries full burden but discloses nothing beyond the schema. It does not say whether the tool waits for a dialog, errors if none exists, what accept/dismiss actually does, or whether prompt_text is ignored for non-prompt dialogs.

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 wasted words. It could be slightly more precise about 'handle' versus 'configure', but it is efficient.

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

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

For a tool with no annotations and no output schema, the description omits operational context about when dialogs are handled and what the tool returns or affects. The schema covers parameters, but the description does not compensate for the missing behavioral and usage information.

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 defines both parameters. The description mentions 'custom action and prompt text' but adds no format, default behavior, or constraint 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?

States a specific verb ('Handle') and resource ('JavaScript dialogs') and enumerates dialog types. It is clear what the tool does, but it does not differentiate itself from any sibling or mention when dialogs arise relative to navigation or click flows.

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

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

No when-to-use guidance is provided. The description does not say to call this when a dialog is present, nor does it name prerequisites, alternatives, or consequences of choosing accept versus dismiss beyond the schema enum.

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

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

No annotations are provided, so the description carries the full disclosure burden. 'Retrieve' implies a safe read, but nothing is said about whether history is per-tab or global, whether it is capped/truncated, or whether any state is affected. This is a significant gap for a tool with zero annotation coverage.

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

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

A single front-loaded sentence with no filler; the resource is named first and the secondary detail ('current index') follows. Nothing needs to be cut.

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

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

With no output schema, the description must cover the return shape, and it only gestures at it ('entries and current index') without saying what an entry contains or the scope of the history. For a zero-parameter read tool this is close to adequate, but the return-value ambiguity is a real gap.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The schema is empty and there is nothing for the description to clarify beyond confirming the tool is parameterless.

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 ('Retrieve') and resource ('tab navigation history entries and current index'), so the agent knows the tool returns browsing history rather than navigating it. It does not, however, differentiate itself from adjacent siblings like browser_list_tabs, browser_back, or browser_forward, which an agent might reasonably confuse it with.

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 statement of when to use this tool, when not to, or which sibling to prefer for related needs (e.g. navigating vs. inspecting history). Usage is only implied by the word 'Retrieve'. For a read-only inspection tool in a 60+ tool browser suite, this leaves routing entirely 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?

With no annotations, the description carries the burden; "List" implies a read-only, side-effect-free operation, and the enumerated fields hint at the response shape, which is reasonable disclosure for a no-param read. It stops short of confirming non-destructiveness, Chrome-version applicability, or whether disabled extensions are included.

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

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

One front-loaded sentence with no filler; the verb and resource lead and the return fields follow. Nothing is redundant or missing.

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

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

For a simple zero-param read tool with no output schema, enumerating the returned fields (IDs, names, versions, enabled status, options URLs) covers what the agent needs. Minor gaps remain around scope (all profiles? disabled extensions?) but nothing critical.

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

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

The tool takes zero parameters, which is the baseline-4 case. The description correctly indicates an unfiltered dump of all extensions, matching the empty schema.

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

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

States a specific verb (List) and resource (installed Chrome extensions) and enumerates the fields returned, so the agent knows exactly what this produces. It does not name a sibling to distinguish against (e.g. browser_extension_action), but the resource is distinctive enough that confusion is unlikely.

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

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

No when-to-use context, no prerequisites, and no mention of alternatives such as browser_extension_action, which operates on extensions. The use case is inferable from the verb, but no guidance is actually 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?

No annotations are provided, so the description carries the full burden. It usefully discloses the return shape (title, URL, ID) which implies a safe read operation, but says nothing about scope (all windows vs. current window), ordering, whether the active tab is included, or any cost. Adequate but with clear gaps for an unannotated tool.

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

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

A single front-loaded sentence that states the action and the returned fields with no filler. Nothing could be cut without losing 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?

With no output schema and no annotations, the description compensates by naming the three returned fields, which is enough for an agent to call a zero-parameter read tool. It stops short of describing scope or ordering behavior, so it is complete-but-minimal rather than fully rounded.

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

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

The tool takes zero parameters, so there is no parameter semantics to document and the baseline of 4 applies. The description adds no misleading parameter-like claims.

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 gives a specific verb+resource ("List all open browser pages/tabs") and names the returned fields (title, URL, ID), so the agent knows exactly what it does. It does not explicitly contrast itself with closely-related siblings like browser_history (tab enumeration) or browser_select_tab, so it falls 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 when-to-use guidance, no exclusions, and no mention of alternatives such as browser_history for past pages or browser_select_tab for switching. The usage is only inferable from the verb "list".

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about whether actions require a resolved element ref versus raw coordinates, whether the call waits for the interaction to settle, or what side effects a drag-and-drop produces.

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 that wastes no words and leads with the resource category before the action list. Slightly terse for a seven-parameter tool, but efficient.

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

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

For a 7-parameter mutation tool with no annotations and no output schema, the description is too thin — it omits parameter wiring (ref vs selector vs coordinates), drag-and-drop source/target requirements, and any failure behavior.

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

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

With 57% schema description coverage, the description adds some meaning by naming the four actions that map to the 'action' enum values. It does not clarify the ref/selector/x-y alternatives or the from_ref/to_ref pairing for drag-and-drop, so the remaining undocumented parameters stay ambiguous.

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?

States a specific resource (mouse operations) and enumerates the four supported actions, so an agent knows exactly what the tool performs. It does not, however, distinguish itself from the sibling browser_click, leaving the 'advanced vs basic' boundary to inference.

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 word 'Advanced' hints that browser_click covers simple clicks, but the description never states when to choose this tool over browser_click or what prerequisites (element ref, page focus) apply. No when-not guidance is given.

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

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

With no annotations, the description carries the full burden. It usefully scopes the effect to all media audio in the active tab, but says nothing about persistence across navigation, tab switching, or reversibility of the change.

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

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

One front-loaded sentence with no filler; every word earns its place and the scope qualifier comes before the effect.

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

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

For a one-parameter, no-output-schema toggle, the description covers the essential behavior. Only persistence and scope-across-tabs details are missing, which are minor for this class of 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 coverage is 100% and the single boolean parameter is already documented, including its default of true. The description's 'mute or unmute' only paraphrases the schema, adding no format or side-effect detail.

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 pairs a specific verb pair (mute/unmute) with a precise resource (all media audio playback in the active tab), so the agent knows exactly what changes. It does not explicitly contrast with siblings like browser_set_media_theme, but no sibling overlaps meaningfully.

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?

Usage is only implied by the verb pair; there is no statement of when to reach for this tool versus alternatives, nor any note that omitting 'muted' defaults to muting. Adequate for a simple toggle but with clear gaps.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about whether navigation blocks/waits for page load, what happens to existing page history, error behavior on invalid URLs, or whether auth/permissions are needed. For a navigation tool with zero annotation coverage, this is a significant gap.

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

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

A single short sentence with no filler, and the key scoping qualifier ('active tab') is front-loaded. It is efficient but almost too terse to be fully informative.

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

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

For a one-parameter navigation tool with no output schema, the description is minimally adequate, but the absence of any load-waiting or error semantics leaves an agent guessing about behavior after 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% and the single 'url' parameter is documented in the schema ('URL to navigate to'). The description adds no format, encoding, or scheme details beyond the schema, 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?

States a specific verb ('navigate'), resource ('active tab'), and target ('URL'), so the agent understands the action is on the currently active tab rather than creating a new one. However, it does not explicitly distinguish itself from the many navigational siblings (browser_forward, browser_back, browser_reload, browser_new_tab), so it falls 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?

No guidance on when to use this versus alternatives such as browser_new_tab, browser_forward, browser_back, or browser_reload. The 'active tab' phrasing implies a precondition but no explicit when/when-not or prerequisites are stated.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the returned data categories (headers, POST payload, response body in JSON/HTML), which is useful behavioral context. However, it does not state that this is a read-only operation, mention permission requirements, rate limits, error behavior for invalid IDs, or whether sensitive data may be exposed.

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?

It is a single sentence that is front-loaded with the core action and resource. Every phrase adds useful detail without redundancy or filler.

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

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

For a simple one-parameter retrieval tool with no output schema and no annotations, the description covers the key return contents and source of the ID. It is nearly complete but could mention failure modes or data size considerations, which are minor gaps given the tool's simplicity.

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 request_id parameter and its source are already documented in the schema. The description reinforces the scope ('for a specific request ID') but does not add syntax, format, or validation details beyond what the schema provides; this meets the baseline 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 states a specific verb (Retrieve), a specific resource (full request details and response body), and a scoping condition (for a specific request ID). It clearly distinguishes this tool from the sibling browser_network_requests by focusing on one request ID rather than listing traffic.

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

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

The description implies when to use the tool: after obtaining a request ID from browser_network_requests, as also noted in the schema. However, it does not explicitly state when not to use it or name alternative tools for other network inspection needs.

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

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

No annotations are provided, so the description carries the full burden. The word 'captured' hints that requests must already exist in the session, which is genuinely useful, but there is no disclosure of capture enablement, retention, pagination beyond the schema default, or whether results include bodies. Adequate but thin for an unannotated tool.

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

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

Two tight sentences with zero filler, and the core action plus purpose are front-loaded in the first clause.

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

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

With no annotations and no output schema, the description is the only place return shape could be described, yet it says nothing about what a request entry contains (method, status, headers, timing) or ordering. For a listing tool this is a noticeable but not fatal 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 limit, filter_type (with its accepted values) and url_pattern. The description only restates that filtering by type or URL pattern is possible, adding no syntax or format detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb ('List') and resource ('captured HTTP/XHR/Fetch/WebSocket network requests'), plus the intent ('for reverse engineering'). It implicitly separates itself from siblings like browser_network_get_response (single response body) and browser_websocket_messages (WS frames only), though it never names them explicitly.

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?

'For reverse engineering' and 'Filter by type or URL pattern' imply when the tool is useful, but there is no explicit when-to-use versus browser_network_get_response or browser_export_traffic, and no stated prerequisite that traffic must already have been captured by navigating.

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

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

With no annotations, the description carries the full behavioral burden and falls short. It does not disclose whether the setting is global or per-tab, whether it persists across navigations, whether it must be reset, or that it mutates browser network conditions for all subsequent requests.

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 efficient sentence that front-loads the action and lists the key inputs. No filler, though it sacrifices completeness for brevity.

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

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

For a stateful, 5-parameter mutation tool with no annotations and no output schema, the description is too thin. It omits scope (tab vs global), persistence, reset semantics, and interaction with the related CPU throttling 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 coverage is 60%, so the description's enumeration of profile values is partially redundant with the enum, but naming 'custom bandwidth and latency' clarifies the latency/download_throughput/upload_throughput intent. It adds some meaning over the schema without fully documenting the units or offline flag behavior.

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

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

States a specific verb ('Emulate') and resource (network profiles/bandwidth/latency), and enumerates the profile values. However, it does not differentiate itself from the closely related sibling browser_set_cpu_throttling, which shares the throttling concept.

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

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

There is no guidance on when to use this tool versus alternatives like browser_set_cpu_throttling or browser_performance_metrics, nor any mention of how to reset throttling back to normal ('none'). The agent is left to infer that this is a stateful emulation toggle.

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

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

With no annotations, the description carries the full burden. It usefully discloses the isolation profile (no shared cookies, clean session storage), which is real behavioral value. It says nothing about lifecycle, though: whether the isolated context persists after the tab closes, how it is referenced later, or whether it becomes the active tab.

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

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

One sentence, front-loaded with the action and immediately qualified by the defining property. No filler and nothing buried.

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, no-output-schema tool, the description covers the essential facts: what it opens and how the context differs. The remaining gap is lifecycle/persistence of the isolated context, which an agent might reasonably wonder about, but it is not critical to invoking the 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% for the single 'url' parameter, including its default of about:blank. The description adds no syntax or format guidance beyond that, so the baseline 3 applies.

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

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

States a specific verb (Open) and resource (new tab) and immediately scopes it to a 'fresh, completely isolated browser context', which is precisely what separates it from the sibling browser_new_tab. The parenthetical definition of isolation (zero shared cookies, clean session storage) removes any ambiguity about which tool to pick.

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 isolation semantics imply when this tool is appropriate (when you need a clean, cookie-free session), but the description never explicitly says 'use browser_new_tab for a normal tab in the shared context' or names any alternative. Usage must be inferred from the contrast with the sibling name alone.

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

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

With no annotations, the description carries the full behavioral burden and largely fails. It doesn't say whether the new tab becomes the active/selected tab, whether cookies/session state is shared with existing tabs, or whether the call returns a tab handle — all of which matter for a tab-creation tool.

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

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

One clean, front-loaded sentence with no filler or redundancy. It is efficient, though its brevity is partly why other dimensions are thin.

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 tab-creation operation amid dozens of browser siblings and with no annotations or output schema, the description omits what an agent most needs: relationship to browser_navigate/browser_new_isolated_tab and post-call tab state. It is under-specified rather than 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%, with the url property documented and defaulted to about:blank in the schema itself. The description only restates 'specified URL', adding no format, scheme, or behavior detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Open a new browser tab') plus the key input (URL), so an agent knows what the tool does. It does not distinguish itself from close siblings like browser_new_isolated_tab or browser_navigate, which is the main reason it falls 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 use this versus browser_navigate (which also takes a URL) or browser_new_isolated_tab (which also creates a tab), nor any mention of prerequisites or resulting tab focus. Usage must be inferred entirely from the name.

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

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

With no annotations, the description carries the full burden. It does disclose one real behavioral trait beyond the schema: 'switch to' indicates it will reuse an existing tab if the page is already open rather than always creating a new one. It says nothing about failure modes for unrecognized page names or any permission/restriction constraints on chrome:// targets.

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

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

One sentence, front-loaded with the verb-resource pair followed by the value list. There is no filler and nothing that needs trimming.

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 single-parameter tool with no output schema and no annotations, the description covers what the tool does and which values it accepts. The only meaningful gap is undefined behavior for invalid or unsupported page names.

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

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

Schema coverage is 100% and the schema already documents the single parameter, so the baseline is 3. The description adds genuine value by listing additional valid values not present in the schema ('bookmarks', 'version', 'gpu', 'net-internals'), effectively expanding the accepted enum.

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 gives a specific verb pair ('Open or switch to') and a precise resource ('Chrome system page'), then enumerates the accepted page names. This clearly separates it from browser_navigate, though it never names that sibling explicitly.

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?

Usage is implied by the enumerated system pages, so an agent can infer this is for chrome:// destinations rather than arbitrary URLs. However, there is no explicit statement of when to prefer this over browser_navigate or browser_list_tabs, and no exclusions 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?

With no annotations provided, the description carries the full disclosure burden. It usefully signals that this is a passive read ('Retrieve') of a point-in-time snapshot ('real-time'), which implies no side effects, and it names the units for heap memory. It does not state whether a page/tab must be active, whether values are cumulative since load, or how often they refresh.

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: verb, resource, then the enumerated return fields. Zero filler, no redundancy, and the most important information leads.

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?

Because there is no output schema, the description must convey what comes back, and it does list the four returned metrics with units for heap. For a zero-parameter, side-effect-free read tool this is nearly complete, though it omits the unit/semantics of 'task duration' and DOM node/layout counts.

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

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

The tool takes zero parameters, so there are no argument semantics to document and the baseline is 4. The description does not need to compensate for any schema gap here.

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

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

The definition gives a specific verb ('Retrieve') plus a clearly scoped resource ('real-time browser performance metrics') and enumerates exactly which metrics are returned (JS heap MB, DOM node count, layout count, task duration). This cleanly separates it from neighbors like browser_network_requests or browser_console_logs. It does not explicitly name a sibling it should be preferred over, which keeps it from 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 reach for this tool versus related diagnostics such as browser_network_requests, browser_console_logs, or browser_system_info. Usage is only faintly implied by the metric names; no prerequisites (e.g. a page must be loaded) or exclusions are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether the key is sent to the focused element, whether it can trigger destructive default actions (e.g., Enter on a form), or any focus/permission requirements.

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

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

A single front-loaded sentence with no wasted words. It states the action and examples 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 simple one-parameter tool with no output schema or annotations, the description is adequate for basic invocation but omits important context about focus target and side effects. It is minimally viable rather than fully complete.

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

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

Schema description coverage is 100%, and the single parameter is fully documented in the schema. The description adds a few more example key names, but they are largely redundant with the schema's 'etc.' and do not add syntax or constraint details.

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

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

States a specific verb ('Press') and resource ('keyboard key'), and gives concrete key examples. It is clearly distinct from sibling tools like browser_click or browser_fill, but does not explicitly name or route against them, so it falls 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 when-to-use guidance, prerequisites, or alternatives. It does not explain when to prefer key presses over browser_fill, browser_click, or browser_mouse, leaving usage entirely 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?

No annotations are provided, so the description carries the full burden, and it discloses almost nothing behavioral: it does not say whether the write is to disk, whether the page must be fully loaded first, what permissions are needed, or what the tool returns on success. For a file-writing operation with zero annotation coverage this is a notable gap.

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

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

A single short front-loaded sentence with no filler or redundancy. It is efficient, though the terseness is part of why so much behavior goes unexplained.

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

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

With no annotations, no output schema, an undocumented parameter, and no explanation of return value or side effects, the definition is too thin for a tool that writes a file to a caller-supplied path. An agent cannot tell what happens on success or on an invalid path.

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 only 50% — save_path is documented in the schema while landscape is undocumented in both places. The description mentions no parameters at all, so it adds nothing to compensate for the uncovered 'landscape' option or explain path format/overwrite behavior.

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

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

States a specific verb+resource ('Print the current page to a PDF file'), which is clear and distinguishes it from the many non-file-producing siblings. It does not, however, explicitly contrast itself with browser_screenshot, the nearest alternative, 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?

No when-to-use guidance is given and no alternative is named, even though browser_screenshot is an obvious overlapping sibling that an agent would need to disambiguate against. The only implicit signal is that this tool produces a PDF file rather than an image.

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

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

With no annotations, the description carries the full behavioral burden, and it says nothing beyond the literal action. It does not disclose whether the call blocks until load completes, how it interacts with in-flight navigation, or that a normal reload may serve cached content (the cache nuance lives only in the schema).

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

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

A single front-loaded sentence with zero filler; every word earns its place for a simple action 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 one-optional-param, no-output-schema action, the description is nearly sufficient to call the tool correctly. The only shortfall is the absence of any note on blocking/wait behavior, which an agent orchestrating a page load might need.

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 single optional parameter (ignore_cache) is fully documented in the schema. The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Reload the current page'), which is unambiguous and distinguishable from siblings like browser_navigate, browser_forward, and browser_back. However, it does not explicitly contrast itself with those navigation siblings, 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 reload versus alternatives such as browser_navigate (fresh URL load) or browser_forward/back. The purpose is implied by the verb but no context, prerequisites, or exclusions 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?

No annotations are provided, so the description carries the full behavioral burden. It does not say what happens if the identifier is unknown, whether removal takes effect immediately or on next navigation, whether it is reversible, or what is returned — all material for a mutation tool.

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

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

One short sentence, front-loaded with verb and resource, with zero filler. Every word earns its place.

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

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

The tool is simple (one required string, no nested objects, no output schema), so little is strictly needed, but with no annotations at all the description should at minimum state the effect of an invalid identifier and whether removal is immediate. Those gaps keep it at minimum-viable rather than 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% and the single parameter is described in the schema itself as "Script identifier returned by browser_add_preload_script," which the description merely restates. No additional syntax, format, or edge-case meaning is added, 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?

States a specific verb (remove) plus resource (preload script) and constrains it to a previously registered script identified by identifier. It is unambiguous among the large sibling set, which contains only one counterpart (browser_add_preload_script).

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 phrase "previously registered" implies the prerequisite that a script must first exist, but there is no explicit when-to-use guidance, no mention of when removal is unnecessary, and no reference to the sibling add tool. Usage is inferable but not stated.

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

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

With no annotations, the description carries the full behavioral burden and largely restates the schema fields. It never says what the tool returns (base64 data, in-memory image, or a file), what happens when save_path is omitted, or whether the capture blocks on page load. These are material gaps for a screenshot tool.

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

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

A single front-loaded sentence enumerating the three capture modes with zero waste. Well sized for the tool's scope.

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

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

Adequate for parameter selection but incomplete for invocation: with no annotations and no output schema, the agent has no statement of the return value (image data vs. saved file) or the effect of omitting save_path. It should do more to cover the behavioral side that structured fields don't.

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 three parameters are already documented in the schema; the description only mirrors the selector/full_page modes. Baseline 3 applies since the schema does the heavy lifting and the description adds no format or default details beyond it.

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

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

States a specific verb ('Capture screenshot') and resource ('current page, entire scrollable page, or a specific element'), which is clearly distinct from the many navigation/interaction siblings. It does not explicitly differentiate itself from the closest alternative, browser_snapshot, so it falls 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 a screenshot over browser_snapshot, browser_get_html, or browser_print_to_pdf, and no preconditions (e.g., page must be loaded, tab must be selected). The three modes are listed but no condition indicates which to choose.

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

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

No annotations are provided, so the description carries the full burden, yet it adds nothing beyond the purpose sentence. It does not state scroll behavior (instant vs smooth), where the scroll is applied (page vs container), what happens when ref/selector match nothing, or how the two modes interact with delta_x/delta_y.

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 that covers both operating modes with no waste. It is appropriately sized for a simple action tool, though it is sparse enough that brevity shades into under-specification.

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

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

With no annotations and no output schema, the description is the only place behavioral context could live, and it stays thin. The 100% schema coverage rescues it to a minimum-viable level, but the two-mode usage model is left for the agent to piece together.

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, setting the baseline at 3. The description faintly maps the two modes (page scroll vs element-into-view) but provides no format or interaction 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?

States a specific verb ('scroll') and both resources (the page, or an element into view). An agent can tell this is a viewport-manipulation tool and not one of the navigation or inspection siblings. It stops short of naming any alternative, but the purpose itself 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?

There is no when-to-use context, no prerequisites, and no routing to alternatives such as browser_snapshot or browser_find_in_page. The agent must infer entirely from the name that this is the tool for moving the viewport.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It says the tool selects and connects to an open tab, but does not disclose side effects (e.g., changing the active tab), behavior on multiple matches, or failure when no tab matches.

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

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

The description is a single efficient sentence that front-loads the action and resource. Every phrase contributes without redundancy.

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

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

The tool is simple with one optional parameter and full schema coverage, so the description is adequate for basic invocation. However, with no annotations and no output schema, it could do more to clarify selection behavior, ambiguity handling, and state changes.

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

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

Schema description coverage is 100%, and the schema already documents the query substring and default behavior when omitted. The description adds 'matching URL or title,' but that meaning is already present in the schema, so baseline 3 is appropriate.

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

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

The description states a specific verb ('Select and connect') and resource ('open browser tab'), and clarifies the matching basis ('URL or title'). It does not explicitly distinguish itself from siblings like browser_list_tabs or browser_new_tab, but the core purpose 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?

There is no explicit guidance on when to use this tool versus alternatives such as browser_list_tabs, browser_new_tab, or browser_navigate. Usage is only implied by the phrase 'by query.'

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

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

No annotations are provided, so the description carries the full disclosure burden, and it offers only the bare mutation verb. It does not say whether an existing cookie with the same name is overwritten, whether the cookie is session- or persistent-scoped, whether a page must be loaded, or whether the change is immediately visible to the page.

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

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

One short, front-loaded sentence with no filler, so it is structurally clean. But it is terse to the point of under-specification rather than genuinely concise, since nothing beyond the obvious is conveyed.

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

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

For a mutation tool with no annotations, no output schema, and zero parameter documentation, the description is materially incomplete. An agent lacks the origin/scoping, overwrite, and persistence details needed to invoke it confidently.

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

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

Schema description coverage is 0% and the description mentions no parameters at all, while the schema has four (name, value, path, domain) with defaults. The agent gets no meaning for path/domain scoping or required name/value pairing from the prose.

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 ('Set a cookie in the browser'), so an agent immediately knows the operation and target. It does not, however, distinguish itself from nearby siblings such as browser_get_cookies or browser_set_headers, leaving the differentiation to naming alone.

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 set a cookie versus using browser_set_headers, browser_eval, or browser_clear_storage, nor any prerequisites (e.g., whether a page/tab must be active or whether the cookie applies to the current origin). Usage must be fully inferred.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the multiplier scale, which is genuinely useful, but says nothing about whether the setting persists across navigations, applies to the current tab or globally, or requires a restart/reset to undo.

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 zero filler; the parenthetical example values are the only elaboration and they earn their 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 one-parameter emulation toggle with no output schema, the core semantics are covered, but scope (tab vs global), persistence, and reset behavior are absent from both description and schema, leaving real gaps for an agent configuring a test environment.

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 already 100% with 'CPU slowdown multiplier', but the description goes further by anchoring the scale with concrete values (1.0 normal, 2.0 2x, 4.0 4x), which makes the multiplier immediately interpretable without experimentation.

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?

States a specific verb and resource ('Emulate slower CPU speeds'), which is unambiguous on its own. It does not, however, distinguish itself from the closely related sibling browser_network_throttling, so the agent must infer that this throttles CPU rather than network.

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 reach for this tool versus browser_network_throttling or browser_performance_metrics, and no mention of restoring normal speed (rate=1.0) when finished. The agent is left to infer the workflow entirely.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It discloses that downloads can be automatically allowed without a popup prompt, which is useful, but it omits whether the setting persists, applies to all tabs, requires permissions, or what happens with deny/default behavior. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single front-loaded sentence with no filler. It states the tool's effect and its most notable behavioral consequence. Every clause 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 two-parameter setter with no output schema, the description covers the basic purpose and one behavioral effect. However, with no annotations and incomplete parameter documentation, it does not provide enough context about scope, persistence, or behavior enum nuances for an agent to invoke it confidently in all cases.

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

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

Schema description coverage is 50%: download_path is documented in the schema, while behavior lacks a schema description but has an enum and default. The description clarifies the 'allow' behavior effect, but does not explain 'deny' or 'default' semantics. With borderline coverage, the description adds some value but does not fully compensate for the undocumented behavior parameter.

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

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

The description states a specific verb and resource: setting the browser download directory and behavior. It is immediately distinguishable from sibling tools such as browser_upload_file or browser_set_user_agent. An agent can tell exactly what this tool configures.

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 explicit guidance on when to use this tool versus alternatives. It implies a download-configuration use case, but does not state prerequisites, timing, or when-not-to-use conditions. An agent must infer all usage context from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It says nothing about whether the override requires a page reload to take effect, whether it persists across navigations or session end, whether location permissions must first be granted (see browser_grant_permissions), or whether it is reversible. For a state-mutating spoofing tool with zero annotation coverage, these are meaningful gaps.

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

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

A single front-loaded sentence that names the action, the target, and the fields. No wasted words and no buried 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?

With no annotations and no output schema, the description is the sole source of behavioral context, yet it omits persistence scope, reload requirements, and permission dependencies. For a browser-state mutation tool this leaves the agent under-informed about side effects.

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

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

Schema description coverage is 100%, so latitude, longitude, and accuracy are already documented in the schema, including the accuracy unit and default. The description only restates the parameter names, adding no syntax or semantics beyond the schema. Baseline 3 applies.

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

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

States a specific verb ('Override') and resource ('device GPS geolocation coordinates') and enumerates the three fields it touches. It is distinguishable from related siblings like browser_set_timezone and browser_set_user_agent, though it never names them explicitly to reinforce the distinction.

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

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

There is no guidance on when to use this versus browser_emulate_environment or browser_set_timezone, nor any stated prerequisites. The agent must infer from the name alone that this is for spoofing location during browser automation.

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

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

No annotations are provided, so the description carries the full burden. 'All outgoing requests from the browser' is useful scope information, but it omits whether this applies to the current tab or all tabs, whether existing headers are overwritten or merged, whether a reload is required, and whether the setting persists across navigation. For a mutation tool with zero annotation coverage this is a notable gap.

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

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

A single efficient sentence with the action front-loaded and no wasted words. It is appropriately sized, though the brevity is partly a product of missing information rather than disciplined editing.

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 state-mutating browser tool with no annotations and no output schema, the description should clarify scope (current tab vs all tabs), persistence, and merge/overwrite behavior. None of that is present, leaving key operational questions unanswered.

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 description merely restates the single parameter's meaning ('custom HTTP headers'), which the schema already documents as 'Key-value map of HTTP headers'. Baseline 3 applies since the schema does the work and the description adds no format, casing, or override 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?

Names a specific verb ('Inject') and resource ('custom HTTP headers') with scope stated as 'all outgoing requests from the browser'. An agent can identify what it does immediately, though it does not differentiate itself from the nearest sibling, browser_set_user_agent, which also alters request headers.

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

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

No when-to-use guidance, no prerequisites, and no mention of how this differs from browser_set_user_agent or other request-modifying tools such as browser_block_urls. The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it largely fails to. It does not disclose that this is a security-sensitive toggle, how long the setting persists, whether it applies globally or to a single tab, or whether a browser restart is needed — all material for a mutation with security implications.

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 well-formed sentence that front-loads the action and scopes it to HTTPS websites. No filler, though the space saved is not spent on the behavioral context the tool needs.

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 toggle with full schema coverage and no output schema, the description is minimally viable: it conveys the toggle's effect. It omits persistence/scope behavior, which is the one thing an agent genuinely cannot infer from the schema, so it 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?

Schema description coverage is 100% for the single boolean parameter, so the baseline is 3. The description hints at the mapping ('bypass' vs 'enforce') which loosely corresponds to ignore=true/false, but adds no format, precedence, or default-override detail 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 names a specific verb pair ('bypass or enforce') and resource ('SSL/TLS certificate warnings on HTTPS websites'), so the agent knows exactly what the tool controls. No sibling among the browser_* tools overlaps with certificate handling, so sibling differentiation is unnecessary. It stops short of 5 only because the dual-direction phrasing slightly obscures which state the tool sets by default.

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 versus navigating, setting headers, or other browser configuration tools, nor any warning about when bypassing certificate errors is inappropriate. Prerequisites and the scope of the change (per-tab, per-session, global) are absent.

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

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

With no annotations, the description carries full behavioral burden. It never states whether the emulation applies to the current tab or all tabs, whether it persists across navigations, or how to revert it (e.g., setting 'no-preference'). This is a meaningful gap for a browser-state mutation.

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; the verb and allowed values come immediately. It is arguably too terse rather than verbose, but structure-wise it is clean.

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 one-parameter tool this is close to adequate, but with no annotations and no output schema the description should at least state scope (tab vs. browser-wide) and persistence/reversal behavior. Those omissions leave an agent guessing about side effects.

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

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

Schema description coverage is 0%, but the single parameter is an enum whose values are self-documenting. The description restates those same three values rather than explaining the semantic effect of each (e.g., how 'no-preference' differs from clearing emulation), so it adds only marginal meaning beyond the schema.

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

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

States a specific verb and resource ('Emulate system color scheme on page') and enumerates the accepted values, so an agent knows exactly what changes. It is reasonably distinct from siblings like browser_emulate_environment or browser_set_viewport, though it doesn't 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?

There is no guidance on when to use this tool, no prerequisites, and no mention of alternatives such as browser_emulate_environment for broader emulation. The purpose is inferable (dark-mode testing), but nothing is stated.

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

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

With no annotations, the description carries full disclosure burden, yet it only clarifies the scale format. It never says whether the change is per-tab or global, whether it persists across navigation, or whether it requires an active page, all of which an agent would want to know.

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

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

Single front-loaded sentence with parenthetical examples; nothing wasteful, and the key semantic detail is embedded compactly.

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 trivial one-parameter setter with no output schema, the description is mostly adequate, but it omits the behavioral context (scope/persistence) that would fully equip an agent to invoke 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 coverage is 100%, so baseline is 3, but the description adds genuine meaning beyond the schema's bare 'Zoom scale factor' by mapping concrete values (0.5=50%, 1.0=100%, 1.5=150%), removing unit ambiguity.

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

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

States a specific verb+resource ('Adjust page zoom level') that is clearly distinct from other browser_set_* siblings. It does not explicitly name an alternative, but the resource is unique enough that no differentiation text is needed.

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 statement of when to use this tool versus e.g. browser_set_viewport or browser_zoom-like alternatives, and no prerequisites (such as requiring a loaded page). Only the name implies usage.

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

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

With no annotations, the description carries the full behavioral burden. It says 'Override' but does not state scope (per-tab vs global), whether the change persists across navigation, whether it applies to already-loaded pages, or whether it is reversible.

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 zero waste; the resource comes first and the examples are parenthetical rather than filler.

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

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

For a state-mutating setter with no annotations and no output schema, key context is missing: invocation scope (tab vs browser-wide), persistence, and timing of effect. The description is under-specified for the operation it performs.

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% for the single parameter, and the schema already labels it 'Timezone identifier.' The inline examples ('America/New_York', 'Europe/Kyiv', 'UTC') usefully demonstrate the IANA format, but this is marginal added value over 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?

Specific verb 'Override' plus resource 'browser timezone' is unambiguous. It does not, however, differentiate itself from siblings like browser_emulate_environment or browser_set_geolocation, which could plausibly also touch timezone-related state.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as browser_emulate_environment. An agent must infer that this is a per-tab override setter.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state whether the override persists across navigation, applies to existing or only future requests, requires a reload, is reversible, or is scoped per-tab. 'Override' implies mutation but the side effects and lifetime are undisclosed.

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 efficient sentence with the resource and scope front-loaded and no filler. It is appropriately sized, though arguably too terse to earn full marks given the missing behavioral detail.

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

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

With 100% schema coverage the parameter is fully specified, so an agent can invoke the tool correctly. However, with no annotations and no output schema, the description leaves the mutation's persistence and reversibility unexplained, which is a meaningful gap for a state-changing 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 single user_agent parameter is already fully documented in the schema. The description adds no format, validity constraints, or examples beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb (Override/set) plus the exact resource (User-Agent string) and scopes it to the browser tab. An agent can understand the operation immediately, though it doesn't explicitly distinguish itself from similar siblings like browser_set_headers or browser_stealth_mode.

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

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

No when-to-use guidance, prerequisites, or alternatives are given. The description doesn't say how this differs from browser_set_headers, browser_emulate_environment, or browser_stealth_mode, which could plausibly also affect the User-Agent.

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

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

With no annotations, the description carries the full behavioral burden. It says 'Set' but never states that this mutates persistent browser/session state, whether the viewport resets on navigation or new tabs, or whether it requires an active tab context. That is a notable gap for a state-mutating tool.

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

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

A single short sentence with no wasted words, front-loading the primary action. It is efficient, though its brevity also reflects the missing guidance rather than disciplined trimming.

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 4-parameter mutation tool with no annotations and no output schema, the description is minimally viable: it names the action and the two concepts covered by the params. It leaves out prerequisites, tab/session scoping, and sibling disambiguation, so it is adequate but with clear gaps.

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

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

Schema description coverage is 100%, so all four parameters (width, height, mobile, device_scale_factor) are already documented with types and defaults. The description adds only the loose phrase 'mobile device emulation', which maps to the mobile and device_scale_factor parameters but adds little beyond the schema. Baseline 3 applies.

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

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

States a specific verb (Set) and resource (browser viewport dimensions and mobile device emulation), so the agent knows the core action. However, it does not differentiate itself from overlapping siblings such as browser_set_page_zoom or browser_emulate_environment, 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?

No when-to-use guidance, no prerequisites, and no alternatives named. The agent is not told whether this must be called per-tab, before navigation, or how it relates to browser_set_page_zoom / browser_emulate_environment.

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

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

With no annotations, the description carries the full burden. It discloses useful behavioral traits (token efficiency, numbered reference scheme, smart labeling, iframe access) but omits whether this is a pure read, whether it triggers any page interaction, and any permission or state requirements. It adds value beyond a tautological restatement but leaves meaningful gaps.

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

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

Two sentences that are front-loaded with the core action and output shape, with the scoping capabilities in a compact trailing clause. Efficient with no filler, though slightly dense in its enumeration of output types.

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?

No output schema exists, and the description does the work of explaining what the snapshot returns (numbered refs, labels, headings, iframes), which is the right division of labor. All three parameters are covered by the schema and two are echoed in prose. The main gap is the absence of any usage steering among the many browser siblings.

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, making 3 the baseline. The description reinforces the selector-scoping and viewport-filtering behavior but adds no syntax, format, or edge-case detail beyond the schema, and it omits any mention of max_elements.

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?

States a specific verb and resource (capture a snapshot of the active page) and details the substance of the output: numbered references, smart labels, headings, iframes. This clearly distinguishes it from visual siblings like browser_screenshot and raw-markup siblings like browser_get_html, though it never names those alternatives directly.

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 explains what the snapshot contains but gives no when-to-use guidance, no conditions for preferring it over browser_screenshot, browser_get_html, or browser_find_in_page, and no exclusions. The 'token-efficient' phrasing hints at LLM-context use but stops short of explicit routing advice.

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