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

The description goes far beyond the annotations by explaining confirmation behavior, covering ops beyond `click` that press controls, reading the role from the observed element rather than the op, and the `keys` single-character policy for sensitive fields. It also discloses environment-dependent behavior (`eval` only when JEVMALLOW_JS=1) and screenshot file conventions. This is rich behavioral context with no contradiction against the annotations.

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

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

The description is dense but fully structured: a one-sentence purpose, a one-line batching rule, a tabular op reference, and focused prose for confirmation and key-handling edge cases. No sentence is filler, and the most important operational guidance is front-loaded.

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

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

Given the tool's complexity, this description is unusually complete: it covers all op kinds, their parameters, default values, confirmation semantics, sensitive-field behavior, environment-gated features, and output style. The presence of an output schema covers the return shape, and the annotations already declare the safety profile, so nothing essential is missing 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?

With 0% schema description coverage, the description carries nearly the entire semantic burden, and it does so well for the required `ops` array by documenting every op and its fields, defaults, and special values. It does not explain the optional top-level parameters (`dry_run`, `session`, `observe_after`, `stop_on_error`), although their names and defaults make their meaning reasonably inferable.

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

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

The description opens with a clear verb and resource: 'Execute one or more ops in order, then return a delta observation.' It also lists the supported operation types in a compact table, making the tool's scope obvious. It does not explicitly distinguish itself from siblings like browser_macro, which could plausibly also execute sequences of actions, so it misses the top score.

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

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

The description gives explicit practical guidance: 'Batch ops into a single call — each call is a round trip,' which tells agents to consolidate actions to reduce latency. It also explains how to handle confirmation-requiring actions and how to properly enter text into protected fields. It does not state when to prefer an alternative sibling tool such as browser_macro or browser_goal.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description correctly adds value by emphasizing 'deterministic' checks and 'Returns pass/fail'. The enumerated check types materially expand behavioral transparency because the schema otherwise reveals only an opaque array of additionalProperties-objects. No contradiction with annotations.

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

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

The two-sentence intro is front-loaded with purpose and outcome, and the example block is compact and information-dense. Each line illustrates a distinct check type with no filler or redundant 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 is complete enough for a tool with a polymorphic checks parameter and an output schema. It covers all major assertion categories and return behavior. Minor gaps remain around exact pattern-matching semantics and the precise pass/fail output structure, but those are not critical for selecting and 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 0%, and the checks items are 'additionalProperties: true', giving no semantics. The description fully compensates by presenting 11 concrete check object shapes with field names like pattern, text, ref, role, name, min, and expr. The session parameter is adequately covered by its schema default.

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 ('verify') and names the resource ('current page'), and explicitly states the return contract ('Returns pass/fail'). The extensive list of concrete check types makes it unmistakable what the tool does and differentiates it from siblings like browser_observe or browser_act.

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 clearly implies this tool is for deterministic assertions on the current page, and the check examples show common scenarios. However, it never explicitly states when to prefer this over siblings such as browser_observe, browser_act, or browser_goal, nor does it mention cases where it should not be used.

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?

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description reveals a non-obvious behavioral trait: only a server-launched browser is actually stopped, while attach-mode browsers are left running. This is valuable context; it could go further by stating what happens to the session after the tab closes, but the key caveat is present.

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 tight and front-loaded: one clear action, one conditional flag, and one caveat. Every sentence earns its place, with no redundant 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?

Given its moderate complexity, an output schema, and annotations, the description covers the main behaviors an agent needs: what is closed, when the browser stops, and how attach mode differs. The main gap is the undocumented session parameter, which keeps this from a 5.

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

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

With 0% schema description coverage, the description must carry parameter meaning. It clearly explains shutdown_browser=True and its attach-mode limits, but it leaves the session parameter undefined beyond the schema title 'Session', so an agent must infer what a session is and what values are valid.

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 opening sentence names a specific verb and resource: it closes a session's tab, with an optional flag to stop the browser. This is clear and not a restatement of the tool name, but it does not explicitly differentiate the tool from siblings such as browser_tabs or browser_act.

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 conditional guidance for shutdown_browser and explains attach-mode behavior, but it never states when to prefer browser_close over browser_tabs, browser_act, or other siblings. The intended use is implied rather than explicitly contrasted.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description doesn't need to restate safety. It adds context by revealing that the tool's behavior is to report environment details and triage failure causes, which is beyond what annotations convey. No contradictions.

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 fluff. The core purpose is front-loaded in the first sentence, and the usage guidance is in the second. Every word earns its place.

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

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

For a diagnostic tool with no parameters, an existing output schema, and annotations covering safety, the description fully equips an agent to decide when to call it and what it can expect. Nothing essential is missing.

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

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

The tool has zero parameters, so the description doesn't need to explain any. The baseline for 0-param tools is 4, and there is no missing parameter information to compensate for.

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 ('Report') and a specific resource ('environment') plus the scope of that report (browser binary, connection, keys, policy envelope). It clearly distinguishes this diagnostic tool from action-oriented siblings like browser_open, browser_act, and browser_close.

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

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

The description explicitly says when to call the tool: 'when anything behaves unexpectedly.' It also clarifies the diagnostic value by separating failure modes. It does not explicitly name alternatives or when not to use it, but the context is clear enough for an agent to route correctly.

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

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

Beyond the annotations, it discloses per-step request cost with speculative fan-out, that verify runs browser_assert-style checks producing facts rather than model claims, and the two provider API routes plus no-key behavior. No contradiction with the readOnly/openWorld/destructive hints.

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 relatively long but every paragraph earns its place: purpose, usage, cost, verification, and auth. It is front-loaded with the core idea and organized so an agent can quickly extract selection and invocation guidance.

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?

Together with the output schema and annotations, the description gives enough context for selection, invocation, auth requirements, cost behavior, and fallback options. It is only slightly incomplete because a few auxiliary parameters like session and max_steps are left without explicit semantics.

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

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

With 0% schema description coverage, the description adds real meaning for url (include or omit), goal (the whole task), and verify (final-page assertions). However, it does not explain session, verbose, or max_steps, so it only partially compensates for the schema's lack of parameter documentation.

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

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

The description states explicitly that the tool hands a whole browser task over, drives the page to completion, and is the entry point for browser work rather than an optimization on top of the manual loop. This clearly distinguishes it from siblings like browser_open, browser_observe, and browser_act.

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

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

It explicitly positions when to use this tool versus the per-click manual loop, names the fallback tools that keep working when no key is set, and gives a clear condition for omitting url when continuing from an existing session. This is actionable 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?

Beyond the sparse annotations (readOnlyHint=false, openWorldHint=true, destructiveHint=false), the description discloses that secrets are never written to the macro and are stored as {{secret}} placeholders, that omitting them 'fails visibly rather than leaking', and that replay refuses to act on weak or ambiguous matches. These are meaningful safety and failure-mode disclosures the annotations do not provide.

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 front-loads the core purpose and then organizes into action definitions, secret handling, and replay semantics. It runs long, but each sentence adds information, and the secret-handling and weak-match-refusal passages earn their length given their safety importance.

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, multi-action tool, the description explains the essential usage contract: actions, placeholder mechanics, and the safety/ambiguity rules. An output schema exists to cover return values, so the main remaining gap is that several parameters (goal, session, start_url, threshold) are left to an input schema with 0% prose coverage.

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

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

Schema description coverage is 0%, so the description carries the burden. It richly documents `action` (five values with their effects), `name` (save/replay target), and `params` (placeholder substitution including the {{secret}} case). It leaves `goal`, `session`, `start_url`, and `threshold` unexplained, though the weak-match refusal partially hints at threshold semantics.

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

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

The opening line 'Record, replay, list, or delete a macro — a discovered path with no model calls' gives specific verbs, a resource, and a defining trait. The 'no model calls' framing distinguishes this from sibling tools like browser_act and browser_observe, which drive live model-mediated interactions.

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

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

The description gives per-action context: record_start 'needs the session to be driving the task', run replays a name with params filling placeholders, and list/inspect/delete are enumerated. It doesn't explicitly name sibling alternatives or state when-not-to-use, but 'a discovered path with no model calls' implies the use case that separates this from live-action 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?

Annotations already mark the tool as read-only and idempotent, and the description adds meaningful behavioral details: the page is re-read, the result may be a full element table or a delta depending on changes, and include_json appends a machine-readable copy. This gives the agent an accurate picture of what to expect without contradicting the annotations.

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

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

The description is compact and front-loaded: the core behavior appears in the first line, followed by concise parameter guidance. Every sentence adds useful information, and there is no filler or repetition.

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

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

The description, annotations, and output schema together cover the important aspects: read-only behavior, mode selection, and return-style options. The main gaps are the undocumented session and include_text parameters and the lack of an explicit pointer to sibling tools, but these are lower-risk because the core usage is clear.

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

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

Schema description coverage is 0%, so the description carries the burden. It explains mode and include_json well, but it does not cover session or include_text, leaving those two parameters undocumented in both schema and description. It partially compensates for the schema gap but not fully.

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

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

The description opens with 'Re-read the page' and names the concrete output ('new element table, or a delta if little changed'), making the operation and resource clear. This clearly differentiates it from siblings like browser_act or browser_assert, which are action/assertion tools rather than observation tools.

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

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

The description explicitly explains when to use each mode: 'auto' for delta when possible, 'full' after a big change, and 'delta' to force. It also tells the agent when to set include_json=True, namely when planning programmatically over the element table.

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

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

Annotations already signal this is not read-only and may have external effects. The description adds useful context about creating an 'owned tab' and echoing back the hint, but it does not disclose details like behavior when the URL fails, whether the current tab changes, or session implications. Acceptable but not rich.

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 tightly written sentences. The first front-loads the core behavior, and the second adds targeted guidance on `hint` without wasting words. Every sentence earns its place.

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

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

For a simple open action with an output schema and annotations, the core behavior is covered. However, the description omits the `session` parameter semantics and does not clarify how this relates to the sibling tools, so an agent may still have unanswered questions about multi-tab or multi-session workflows.

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

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

Schema description coverage is 0%, so the description must compensate. It explains `hint` well but says nothing about `url` or `session`. The `url` is required and only typed as string; the description does not add format, protocol, or usage guidance. Only one of three parameters gains real semantic value from the text.

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 URL in a new owned tab and return the element table.' This clearly distinguishes it from sibling tools like browser_tabs or browser_observe by emphasizing the new owned tab and the returned element table.

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 makes clear this is the entry action for opening a URL and gives specific guidance for using the `hint` parameter. It does not explicitly name alternatives or exclusions, but the open-and-return-table purpose is unambiguous enough for an agent to select it.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds a bit of conceptual context by explaining that sessions are 'independent owned tabs,' but it does not disclose return format, pagination, or any other behavioral nuance.

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 with no filler or redundant wording. The key action and resource definition are front-loaded, and every word earns its place.

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

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

For a zero-parameter, read-only listing tool with an output schema present, the description is nearly complete. It would be stronger if it explicitly mentioned the relationship to browser_tabs, but nothing needed to make the call itself is missing.

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

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

The input schema has no parameters, so the description does not need to explain parameter semantics. Baseline 4 applies for a zero-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?

States a specific verb ('List'), a resource ('open sessions'), and defines that resource as 'independent owned tabs,' which distinguishes it from the sibling browser_tabs. An agent can tell what this tool does and roughly what it returns.

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

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

No guidance is given about when to use this tool versus alternatives such as browser_tabs. The parenthetical helps define the concept but does not explicitly state when this tool should be selected or when another tool is preferred.

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

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

The description adds meaningful behavioral context beyond the annotations: tabs opened by the page appear in observations automatically, indexes are positional and get renumbered, `target_id` is a `#handle`, and `url` is validated against the domain envelope. This goes well beyond the readOnly/openWorld/destructive hints. It is not contradictory to the annotations; closing tabs is consistent with destructiveHint=false since no data destruction is implied.

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

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

The description is compact, front-loaded with the primary purpose, and each subsequent sentence earns its place by clarifying tab handles, index semantics, current-tab behavior, and URL validation. There is no filler or repetition of schema data.

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 explains the trickiest aspects of tab management and an output schema exists, so return values are not required. But it still omits the allowed `action` values (beyond inferring them from the first sentence) and leaves `session` undefined, so an agent cannot fully determine correct invocation for all intended uses.

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

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

With 0% schema description coverage, the description carries the burden of explaining parameters. It does this well for `target_id`, `index`, and `url`, explaining the handle mechanism, positional instability, and domain-envelope check. However, it never documents `action` values beyond `action="list"` or explains the `session` parameter at all, leaving meaningful gaps for a 5-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 opens with a clear verb-resource pair: 'List, open, switch to, or close tabs.' This makes the tool's domain obvious and distinguishes it as tab-focused from siblings like browser_open or browser_observe. It loses the top score because it advertises multiple operations rather than one specific verb and does not explicitly contrast itself with overlapping siblings.

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

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

The description gives concrete direction on how to use the tool: prefer `target_id` over `index`, use `index` only when listing and acting in the same breath, and omit both to mean the current tab. It also explains the domain-envelope check for `url`. It stops short of explicit when-not-to-use or alternative-tool routing, so it earns a 4 rather than a 5.

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