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

Beyond the sparse annotations, the description discloses that calls return a delta observation, that batching saves round trips, that confirmation-required actions surface needs_confirmation and require re-sending with confirm: true, and that eval is gated by JEVMCP_ALLOW_JS=1. This enriches readOnlyHint=false and openWorldHint=true without contradicting either.

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 main behavior, round-trip concern, and op reference are packed into a compact front-loaded table with no filler. Each row and caveat 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 high-complexity multi-op tool, this is a near-complete manual: all ops, timing defaults, confirmation flow, and the eval gate are covered, and the output schema covers return value details. Minor missing context is the semantics of the four top-level flags, though their names/defaults make them partially self-explanatory.

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 compensates with a detailed op/fields table covering refs, optional flags, defaults, and value formats. However, the top-level parameters beyond ops (dry_run, session, observe_after, stop_on_error) are not explained beyond their schema names and defaults.

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 first line states a specific verb and object: execute browser operations in order and return a delta observation. The op table makes it clearly an action tool, distinguishable from siblings like browser_observe, browser_tabs, 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?

It gives explicit batching advice: 'Batch ops into a single call — each call is a round trip,' so an agent knows to combine operations. It does not explicitly name sibling alternatives or when-not-to-use conditions, though the op table largely implies the tool's scope.

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?

The description discloses key behavioral traits: cost per step (one request per operation and fan-out), verification behavior (runs browser_assert-style checks for factual results), and API key requirements (TYPESAFE_API_KEY or OPENROUTER_API_KEY) as well as the no-key case. It adds context beyond the annotations (which only say non-read-only and open world), such as the implication of non-read-only via key requirements, though not explicitly stating mutability or potential side effects.

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

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

The description is well-structured, starting with a clear one-line purpose, then explaining the entry-point nature, URL omission, cost model, and API key details. Each paragraph adds distinct value. It's somewhat long but every sentence carries important information for an agent deciding and calling the tool. No fluff.

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

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

Given the complexity (6 parameters, no schema description, output schema exists), the description covers most critical aspects: when to use, key requirements, cost implications, and verification. It doesn't detail all parameters (e.g., `session`, `max_steps`) but those are lower-stakes, and the output schema likely describes return values. It's comprehensive enough for an agent to invoke correctly without major 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 has 0% coverage on parameters, so the description must compensate. The description explains `url` (optional, for continuation) and `verify` (runs checks on final page), but does not explain `goal`, `session`, `verbose`, or `max_steps`. However, it covers the two most semantically significant parameters, and with 6 parameters, the coverage rate is high enough, though not complete, to warrant a 4 rather than a 3.

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

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

The description clearly states the tool's purpose: to hand over a whole browser task, opening a URL and driving the page to completion in one call. It distinguishes itself from the manual loop (browser_act per click) and explicitly names the entry-point nature. The phrase 'Hand a whole browser task over' is a strong verb+resource statement.

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

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

Provides explicit guidance on when to use: as the entry point for browser work, not an optimization on the manual loop. It also tells the agent when to omit `url` (when continuing from an existing session) and contrasts with siblings by saying reading a page needs no key, while handoff is unavailable without a key. This effectively routes to alternatives.

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

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

Beyond the annotations, the description adds meaningful behavioral details: replay re-resolves each step by role and name, refuses to act on weak/ambiguous matches, and macros contain no model calls. There is no contradiction with the annotations' readOnlyHint=false and destructiveHint=false.

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 with a one-line summary followed by an action-oriented reference list. Every line earns its place, and there is no redundant prose or restating of schema fields.

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 output schema exists, so return values need not be described, but the tool is polymorphic with five actions and seven parameters. The description does not specify parameter requirements per action, what delete or inspect do in detail, or how threshold and start_url affect replay, leaving gaps for an agent 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?

Schema description coverage is 0%, so the description carries the burden of explaining parameters. It does clarify action, name, params, and session indirectly, but threshold, start_url, and goal are left unexplained, and it is unclear which parameters apply to which actions beyond run/record_stop.

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

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

The description opens with a specific verb-and-resource statement: 'Record, replay, list, or delete a macro — a discovered path with no model calls.' This clearly distinguishes browser_macro from the other browser_* siblings, which focus on opening, observing, acting, or asserting, not on managing reusable discovered paths.

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 action-level guidance, including a prerequisite for record_start ('needs the session to be driving the task') and explains when to use run. However, it does not explicitly say when to choose browser_macro over related tools like browser_act or browser_observe, leaving some usage inference to the 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?

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?

Annotations already establish the tool is not read-only and not destructive/open-world; the description adds critical runtime behavior: page-opened tabs appear in observations, target_id is stable via '#handle', and index is unstable across list changes. This explains why an index read earlier may point at a different tab, which annotations alone cannot convey. It does not disclose session persistence or close side effects, but the core risk is covered.

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

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

The description is compact: a one-line action summary followed by a focused paragraph on handle/index pitfalls. Every sentence contributes either scope or usage nuance, with 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 multi-action 5-parameter tool, the description covers the most important usage pitfalls and the current-tab default, and the output schema exists to document return shape. The main gap is the absence of explicit parameter-to-action mapping for url and session, though defaults and the opening action list make these mostly inferable.

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

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

With 0% schema coverage, the description must compensate, and it does for the two hardest parameters: target_id and index, including their semantics and defaults. It also grounds action='list' by referencing the '#handle' it prints. However, url, session, and the full action value set are not explicitly defined, leaving some inference required.

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

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

The opening line 'List, open, switch to, or close tabs' gives a specific verb set and resource, making the tool's scope immediately clear. It does not explicitly contrast with sibling tools like browser_open or browser_close, but 'tabs' as the resource and the multi-action framing differentiate it well enough.

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

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

The second paragraph gives explicit how-to guidance: prefer target_id over index because indexes are positional and renumber, use index only when listing and acting in the same breath, and omit both to target the current tab. This is clear context for when each addressing mode should be used, though it does not name alternatives such as browser_observe or browser_open.

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