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

No annotations are provided, so the description carries the burden of behavioral disclosure. The term 'Detect' conveys a read-only inspection and the listed outputs are helpful, but the description does not state whether the tool waits for page load, probes network activity, or is strictly passive.

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

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

The description is a single compact sentence, front-loaded with the verb and object, and the parenthetical packs output detail without unnecessary words. 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?

For a two-parameter read-only detector with an output schema, the description is mostly sufficient at a high level. However, the missing parameter explanations and absent usage guidance leave gaps that an agent must infer from sibling tools or naming conventions.

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 does not mention the 'tab' or 'session' parameters at all, adding no meaning beyond the schema's names and defaults. The generic browser-context parameters are somewhat self-explanatory, but the description fails to compensate for the coverage gap.

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

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

The description uses a specific verb ('Detect') with a clear resource ('captcha widgets on the current page') and enumerates the output facets (type, evidence, sitekeys). This clearly distinguishes it from the sibling tools browser_captcha_solve and browser_captcha_manual_wait.

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 the tool is for inspecting captchas before solving or waiting, but it never explicitly states when to use it versus browser_captcha_solve or browser_captcha_manual_wait, nor does it give exclusions. The 'on the current page' scope provides context, but there is no direct alternative-routing 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 behavioral burden. It discloses that the tool polls, waits, and requires a visible browser environment. It does not mention edge behavior such as whether timeout_s=null means it can block indefinitely or what happens when the timeout is reached.

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 purpose, then adds the environment prerequisite and polling behavior. Every clause earns its place with 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 tool has four parameters, no annotations, and no schema descriptions, but the description covers only the high-level behavior and environment requirement. An agent is left without parameter semantics or explicit routing between this tool and browser_captcha_solve, so the definition is not complete enough for confident selection and 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 0%, so the description must compensate for the four parameters, but it mentions none of them. tab, poll_s, session, and timeout_s are left to be inferred solely from their names and defaults, which is not enough for reliable invocation.

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: wait for a human to solve a captcha. It also gives the termination condition ('until the captcha disappears') and differentiates itself from automatic solve/captcha-detection siblings via the words 'manual' and 'human'.

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

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

The description provides a clear usage context: use this when a human is solving a captcha, and it requires a visible browser (NAVIGATOR_HEADLESS=false or VNC). It does not explicitly name alternatives like browser_captcha_solve, but the manual-vs-automatic distinction is strongly 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 behavioral burden. It discloses that automatic solving requires an external provider key and which captcha types are supported, but it does not explain side effects such as whether it submits the page, how it waits, possible failures, or rate/cost implications of calling an external service.

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

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

The description is concise and front-loaded: the core action is stated in the first sentence, and the following lines add requirements and supported types without repetition 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?

Given the output schema is present, not explaining return values is acceptable. The main gaps are parameter semantics (tab/session/provider) and lack of usage context versus siblings, making it only partially complete for a tool with four optional parameters and no annotations.

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

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

Schema description coverage is 0%, so the description must explain the four parameters. It only hints at 'ref' for plain image captchas and indirectly at 'provider' via the key names; 'tab', 'session', and the meaning/range of 'provider' are left undocumented. This does not compensate for the schema gap.

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

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

The first sentence states a clear action on a specific resource: 'Solve the captcha on the current page automatically.' It further specifies supported captcha types (reCAPTCHA v2, hCaptcha, Turnstile, plain image), which distinguishes it from sibling tools like browser_captcha_detect and browser_captcha_manual_wait.

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 useful context: use it to solve the current page's captcha automatically, and it needs a provider API key. However, it never names alternatives or states when not to use it (e.g., when manual approval is required, use browser_captcha_manual_wait), so the guidance is implied rather than explicit.

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

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

With no annotations, the description carries the burden. It discloses one behavioral trait: human-like mouse movement when humanization is enabled. But it does not mention other important behaviors such as auto-scrolling into view, waiting for load, error handling on missing ref, or any side effects. The disclosure adds some value but is far from complete.

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

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

Two sentences, front-loaded with the main action and target, followed by a relevant behavioral note. Every word earns its place; no fluff 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 is insufficient for a 5-parameter tool with zero annotations and no parameter documentation. It leaves unaddressed the purpose and valid values of four parameters, how to obtain a ref (only implied via 'snapshot'), and what happens on failure. An output schema exists but is not visible to the agent, so it cannot compensate.

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 only explains 'ref' with an example and leaves 'tab', 'button', 'double', and 'session' entirely unexplained. While names suggest meaning, the agent gets no explicit guidance on how these parameters affect behavior, making it hard to invoke correctly for non-default cases.

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 action ('Click') with a precise target ('element by its ref from the snapshot') and gives a concrete example ('e12'). This differentiates it from siblings like browser_click_text (click by text) and browser_hover (hover), so the agent immediately knows what this tool does.

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 the primary use case: clicking an element identified by a snapshot ref. However, it does not explicitly explain when to prefer this over browser_click_text, nor any exclusions (e.g., when the element is off-screen or lacks a ref). The context of using a ref from a snapshot is clear but not contrasted with 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?

No annotations are provided, so the description carries the full burden. It discloses that this is a fallback click by visible text, but doesn't mention behavioral traits like whether it clicks the first match by default (nth=0), what happens if no text is found, whether it waits for the element, or if it can click hidden elements. The 'nth' parameter implies multiple matches are possible, but the description doesn't explain this behavior.

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

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

The description is a single, concise sentence that front-loads the core purpose and usage condition. It's efficient with no wasted words. However, it could be slightly more structured by adding a second sentence for parameter clarification, but as-is it's appropriately sized for a simple tool.

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

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

Given the tool has 4 parameters, 0% schema coverage, no annotations, and an output schema exists, the description is incomplete. It doesn't explain the meaning of 'nth', 'tab', or 'session', nor does it describe what the output contains (though the output schema exists, the description doesn't reference it). For a fallback tool that might be used in complex automation flows, more context is needed about matching behavior and error 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 0%, so the description must compensate. It only explains the 'text' parameter implicitly (the visible text to click). It doesn't explain 'nth' (which match to click), 'tab' (which tab to operate in), or 'session' (which session to use). The description adds minimal value beyond the schema for these parameters.

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

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

The description states a specific verb ('click') and resource ('visible text'), and explicitly frames it as a fallback method. It distinguishes itself from the sibling browser_click (which presumably uses a ref/selector) by noting it's used when no ref is available. However, it doesn't fully elaborate on what 'ref' means in this context, leaving slight ambiguity.

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

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

The description gives a clear usage condition: use this when no ref is available. This implies the alternative (browser_click) should be used when a ref is available. It doesn't explicitly name the alternative tool, but the context of siblings and the phrase 'fallback' provide adequate guidance. It could be stronger by explicitly naming browser_click as the preferred 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 burden. It discloses the core action (accept/dismiss with optional text) and the manual-mode context, but it does not state what happens if no dialog is pending, whether the call blocks or errors, or what the return value is.

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 a front-loaded verb and no filler. It packs the key conditions and options into minimal space.

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

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

For a tool with four optional parameters, no annotations, and no explanation of tab/session targeting, this is thin. The output schema exists but the description still doesn't tell an agent which dialog/session is affected or how to verify success.

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 maps accept/dismiss to the accept parameter and 'optional text' to text, but says nothing about tab or session, which are ambiguous for targeting the right dialog.

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 clear verb ('Respond') and specific resource ('pending manual-mode dialog'), and it mentions the accept/dismiss action and optional text. It does not explicitly name sibling tools like browser_set_dialog_mode or browser_read_dialogs, so differentiation is mostly implicit via 'manual-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?

The phrase 'pending manual-mode dialog' sets a clear precondition: only call when a manual-mode dialog is pending. But there is no explicit when-not or alternative routing, such as using browser_read_dialogs to inspect first or browser_set_dialog_mode for automatic handling.

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 burden of behavioral disclosure. It mentions the data source (capture or live) but does not state whether the tool is read-only, whether prior network capture is required, what happens if no APIs are found, or if it has any side effects on the page or session. This is a significant gap for a discovery tool that might modify state indirectly.

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

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

The description is a single sentence that is direct and front-loaded with the core purpose. There is no filler or redundant wording. It could be slightly more structured with usage notes, but it is appropriately concise for the amount of information it conveys.

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 three parameters with no schema descriptions, no annotations, and only a minimal description. Although an output schema exists (which may cover return values), the description omits prerequisites (e.g., whether capture must be active), parameter semantics, and behavioral traits. An agent cannot reliably call this tool correctly without further inference or external documentation.

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 none of the three parameters (tab, limit, session). The description does not explain what 'tab' refers to, how 'limit' constrains results, or how 'session' is used. Since the schema provides no descriptions, the description must compensate, but it offers nothing about parameter semantics.

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

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

The description clearly states a specific action (discover), a precise resource (background API endpoints used by the page), and narrows scope to fetch/XHR, including internal/undocumented APIs. This distinguishes it from sibling network tools like browser_network_list, which list observed requests rather than discover endpoints. The phrase 'from capture or live observation' adds context that it works across two modes.

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

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

The description implies usage via 'from capture or live observation' but does not explicitly state when to prefer this tool over siblings like browser_network_capture_start, browser_network_list, or browser_evaluate. It neither names alternatives nor gives conditions for selection, leaving the agent to infer. No explicit 'use this when...' guidance is present.

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 bears the full burden. It only states the action without disclosing any side effects, such as whether the drag triggers events, clicks, or navigation, or whether it waits for drag-and-drop to complete. No mention of potential delays or failures.

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

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

Single sentence, concise and to the point. It is efficient but lacks necessary context. However, for a simple tool, the brevity is acceptable, and the structure is clear.

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 in complexity, but with zero schema coverage and no annotations, the description is insufficient. It doesn't explain what ref_a and ref_b refer to, nor the behavior of the drag operation (e.g., does it need a page loaded? what happens on success?). An agent would have to guess.

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

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

Schema coverage is 0%, and the description only maps two parameters (ref_a, ref_b) to 'drag element ref_a onto ref_b'. Parameters 'tab' and 'session' are not explained at all, and ref_a/ref_b are not elaborated (e.g., they are references to what? DOM element ids?). The description fails to compensate for the schema's lack of descriptions.

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

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

Description clearly states the action (drag) and the two required elements (ref_a onto ref_b). It is distinct from siblings like browser_click or browser_scroll, but doesn't explicitly differentiate from potential drag-and-drop alternatives (none exist). The verb and resource are specific 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?

No guidance on when to use this tool vs alternatives, nor any conditions or prerequisites (e.g., requires elements to be visible, or that a page must be loaded). The description is minimal and doesn't mention when not to use it. This is a common 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 that arbitrary page-level JavaScript is allowed, that results are returned, and that promise-returning expressions work (via the fetch example). The 'raw power, use responsibly' warning conveys potential side effects, though it does not enumerate specific risks such as navigation, mutation, or data leakage.

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 short, front-loaded with the core purpose, and every sentence contributes. The function-expression guidance and the 'raw power' warning are compact but high-value, making the text efficient and readable.

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 covers the main invocation pattern, result return, and the breadth of allowed execution, and an output schema exists for return values. However, it does not explain tab/session disambiguation, serialization behavior, error handling, or the execution context of the expression, leaving some gaps for a raw JavaScript evaluation tool.

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

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

Schema description coverage is 0%, so the description must add meaning. It clearly explains the 'expression' parameter and demonstrates how 'arg' is passed into the function. However, it does not clarify the 'tab' or 'session' parameters, leaving their role entirely to the agent to infer.

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

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

The description uses a specific verb and resource: 'Evaluate JavaScript in the page and return the result.' This clearly distinguishes the tool from sibling tools that snapshot, extract, click, fill, or navigate, because those are page actions rather than arbitrary JavaScript evaluation.

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 instruction to prefer a function expression and to pass arguments via the 'arg' parameter gives concrete guidance on how to invoke the tool. It also implies the tool is for any page capability not covered by dedicated browser tools, though it does not explicitly name alternatives or exclusion cases.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It conveys a read-only listing action, but it does not explain how the tab and session parameters scope the operation, what happens when no forms exist, or whether any page-load condition is required. The main behavior is clear, but scope details are left to inference.

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-structured sentence that front-loads the action ('List forms and their fields') and immediately links to the use case. Every word earns its place with no redundancy.

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

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

An output schema exists, so return values are covered. However, the tool has two optional parameters with zero semantic coverage and the description fails to address their meaning or how they affect the set of forms returned. The core purpose is clear, but the scoping parameters make the definition only partially complete.

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

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

The schema has 0% description coverage, and the description never mentions 'tab' or 'session'. Both parameters are defined only by type and default, so an agent cannot infer what they control or how to target a specific tab or session. The description does nothing to compensate for the schema gap.

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

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

The description states a specific verb ('List') and resource ('forms and their fields'), and immediately frames it as 'the map for browser_fill_form'. This clearly distinguishes the tool from the many extraction siblings (text, html, links, tables) by focusing on forms and tying it to a related action.

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: as a preparatory step for browser_fill_form, since it provides the 'map' of form fields. It names a dependent sibling explicitly, giving an agent context for sequencing, though it does not state exclusions or alternatives beyond that connection.

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 the key behavioral distinction between whole-document and element-scoped extraction via the ref parameter. However, with no annotations provided, it carries the full burden of behavior and does not say whether the HTML is raw source or serialized DOM, whether it triggers JavaScript, or whether there are any size/rate limit 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?

One clean, front-loaded sentence with no filler. Every word earns its place, and the main operation is stated 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?

Despite having an output schema, the input semantics for tab, limit, offset, and session are absent, and the description provides no guidance about alternatives. An agent can make a basic default call, but cannot correctly reason about pagination, non-default sessions, or selecting a non-default tab.

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 phrase 'by ref' adds meaning to the ref parameter, and the whole-document behavior for an absent ref is implied. But with 0% schema description coverage, the tab, limit, offset, and session parameters are completely undocumented in both the schema and description, leaving a major gap for correct invocation.

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

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

The description names a specific verb and resource — 'Extract HTML' — and further narrows the scope to either the whole document or a specific element by ref. This clearly distinguishes it from sibling extract_* tools by output type and from browser_snapshot or browser_evaluate.

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

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

The description gives no guidance on when to choose this tool over browser_extract_text, browser_extract_links, browser_snapshot, or browser_evaluate. It does not mention alternatives or exclusion conditions, so the agent must infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden. It does disclose meaningful behavior: links are deduplicated and hrefs are resolved. It does not explain edge cases like whether only anchor tags are included, but the core non-obvious behaviors are stated.

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

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

The description is a single, front-loaded sentence with no filler. Every word adds meaning, and the key qualifiers are placed immediately after the action.

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

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

The description is too sparse for a tool with three undocumented parameters and no annotations. An agent cannot tell what tab, session, or limit mean, and the 'all links' wording obscures the effect of the default limit.

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 none of the three parameters: tab, limit, or session. The phrase 'List all links' even conflicts with the default limit of 100, leaving the agent unable to infer parameter 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?

The description uses a specific verb and resource: 'List all links' with two clarifying qualifiers, 'deduplicated' and 'resolved hrefs.' This clearly distinguishes it from sibling tools like browser_extract_text, browser_extract_html, and browser_extract_tables.

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

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

The description gives no guidance on when to use this tool instead of browser_extract_html, browser_find, or browser_snapshot. No alternatives, exclusions, or contextual trigger conditions are mentioned.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only lists output content and never states whether the tool is read-only, whether it acts on the active tab or a specific tab, or what happens when metadata is absent. 'Extract' weakly implies a read operation, but that is not sufficient disclosure.

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 with no filler and the key verb front-loaded. It is appropriately concise for the purpose, though this brevity comes at the cost of behavioral and parameter 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 no annotations and 0% parameter-doc coverage, the definition is not complete enough for reliable invocation; the output schema covers return shape, but the agent still lacks tab/session semantics and usage guidance. The missing context is material for a browser tool operating across sessions and tabs.

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 needed to explain tab and session, but it does not. It gives no meaning to either parameter beyond their names and defaults, leaving the agent to guess whether null tab targets the active page or requires a tab id.

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

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

The description uses a specific verb and resource ('Extract page metadata') and enumerates the exact fields returned (title, meta tags, OpenGraph, canonical). This makes it immediately distinguishable from sibling extractors like browser_extract_text or browser_extract_links, even without naming them.

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

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

The purpose statement subtly implies using the tool when page metadata is needed, but it provides no explicit when-to-use guidance, no prerequisites, and no comparison with sibling extraction tools. The agent must infer that this is the right tool among many browser_extract_* 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?

No annotations are provided, so the description carries the full burden. It mentions 'token-cheap vs HTML' which hints at output size behavior, but it doesn't disclose what happens with malformed tables, nested tables, or whether the tool modifies the browser state. It also doesn't clarify if the extraction is read-only or if it might affect the page. The description is too brief to provide meaningful behavioral transparency.

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

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

The description is a single sentence, extremely concise and front-loaded with the core action. The parenthetical 'token-cheap vs HTML' adds a useful efficiency hint without bloat. It earns its place, though it could be slightly more informative without losing conciseness.

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

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

The tool has an output schema (not shown in detail) and 3 optional parameters, but the description is too sparse to be complete. It doesn't explain the meaning of the parameters, the exact structure of the row arrays, or how it handles edge cases like tables with headers, merged cells, or multiple tables on a page. For a tool with no annotations and 0% schema coverage, this is a significant 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 0%, so the description must compensate. It doesn't explain what 'tab', 'session', or 'limit_rows' mean. 'limit_rows' is somewhat inferable from the name, but 'tab' and 'session' are ambiguous without context. The description adds no parameter-level meaning beyond the schema's bare 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 description states a specific verb and resource: 'Extract <table> content as row arrays'. It clearly identifies what the tool does and the output format. It doesn't explicitly distinguish from sibling tools like browser_extract_text or browser_extract_html, but the focus on tables and row arrays is specific enough to differentiate it from most siblings.

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

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

The description implies usage: use this when you need table content in a token-cheap row-array format. It doesn't explicitly state when not to use it or name alternatives like browser_extract_html for full HTML or browser_extract_text for general text. The 'token-cheap vs HTML' hint provides some context for choosing it over HTML extraction, but it's not explicit.

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

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

With no annotations, the description carries the behavioral burden. It does disclose meaningful behavior: 'smart main-content' extraction and pagination via offset/limit. However, it stays silent on side effects, prerequisites (e.g., active tab), and how element selection is resolved, so it only partially uncovers the tool's behavior.

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

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

Two sentences with no filler; the core purpose is front-loaded and the pagination note is a single efficient clause. 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 has an output schema, so return values need no description. However, the description does not clarify the critical ref parameter that selects the specific element, nor the roles of tab and session. For a tool with 5 parameters and zero schema coverage, this leaves a noticeable gap in what an agent needs to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains offset/limit ('pagination for very long pages') and vaguely references element selection ('specific element') without binding it to the ref parameter. The ref, tab, and session parameters receive no semantic explanation, leaving most parameters undocumented.

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

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

The description uses a specific verb and resource ('Extract text') and clearly scopes the operation: whole page via smart main-content or a specific element. This differentiates it well from sibling extract tools like browser_extract_html and browser_extract_links without needing to inspect schemas.

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 useful context for when to use it ('very long pages' with pagination) but never explicitly states when to choose this over alternatives like browser_snapshot, browser_extract_html, or browser_extract_links. Usage is implied by the tool name and text-extraction purpose, but no exclusions or alternative routing 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. It discloses the fill action and the optional Enter press, but not whether the field is cleared, whether input events fire, whether page navigation or form submission occurs, or what side effects the default session/tab behavior has.

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

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

The description is two short sentences with the core action front-loaded and no redundant prose. It is appropriately terse, though the brevity also reflects the missing parameter and side-effect 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?

Even with an output schema present, the description leaves the most important parameter (ref) unexplained and gives no guidance about side effects or when to use the optional session/tab parameters. For a five-parameter tool with no annotations, this is incomplete.

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

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

Schema description coverage is 0%, so the description must compensate for the missing parameter documentation. Only submit's behavior is explained; ref, text, tab, and session are left undefined, and 'by ref' does not clarify where an agent obtains a valid ref.

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 concrete action and target: 'Fill a field by ref' distinguishes this from broader fill-form or click tools. However, it does not explicitly contrast with browser_fill_form or clarify what a 'ref' is, so sibling differentiation is only implicit.

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

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

The only usage hint is 'Set submit=true to press Enter afterwards,' which conditions a parameter but does not explain when to prefer this tool over browser_fill_form, browser_click_text, or browser_press_key. No alternatives, exclusions, or prerequisites are mentioned.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It reveals that it fills fields and may submit the form, but does not mention potential side effects, error handling, or whether it waits for page updates. It is adequate but not exhaustive.

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 compact sentences with a practical example, front-loaded with the core benefit. No wasted words.

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

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

The description covers the main functionality (fields and submit) but omits details about 'tab' and 'session' parameters, and does not mention error behavior or the output schema (though it exists separately). For a simple form-filling tool, it is mostly complete, but gaps remain.

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

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

The description gives an example for the 'fields' parameter (ref/value) and mentions the 'submit' boolean, adding meaning beyond the schema which only defines an array of objects. However, 'tab' and 'session' are not explained, and schema coverage is 0%, so the description must compensate; it only partially 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 states exactly what the tool does: 'Fill multiple fields in one call', which is a specific verb and resource, and it contrasts itself with filling one field at a time, distinguishing it from sibling tools like browser_fill.

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

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

It implies the primary use case (multiple fields) and notes the optional submit behavior, but does not explicitly name alternatives or provide exclusion criteria. The phrase 'much faster than one fill per field' hints at the alternative but stops short of a direct when-to-use statement.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It openly reveals that by default it searches only actionable elements (links, buttons, fields, headings, images) and that include_structural=true expands to containers, plus the performance advantage over snapshots. It does not mention read-only safety or error behavior, but 'search' implies a non-mutating operation, and these disclosures are meaningful beyond the empty 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 two sentences, front-loaded with the core purpose and followed by a practical efficiency note and filtering detail. Every sentence adds value without fluff. It is appropriately sized and structured for quick agent consumption.

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

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

Given the output schema exists and likely documents the return format, the description covers the primary search behavior and the include_structural option. It misses explicit details on limit/tab/session, but these are common across sibling browser tools and have defaults. The description is complete enough for an agent to know when and how to invoke the tool for its core use case.

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 pattern (regex ok), role (ARIA role), and include_structural (matches containers), but omits limit, tab, and session parameters entirely. With six parameters, covering only three leaves the agent needing to infer default behavior for the rest, which is a partial compensation. The default limit of 20 is not mentioned, nor how to select a specific tab or session.

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 searches the current page for elements matching a text pattern (regex) and/or ARIA role, and returns matching element refs. It distinguishes itself from a full snapshot by noting it is 'cheaper' and from extraction tools by implying a search use case. The verb 'search' and specific resource 'current page' are precise.

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

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

It explicitly recommends using this tool when you 'know what you're looking for' rather than taking a full snapshot, providing a clear use case. It does not explicitly name other alternatives like browser_extract_text, but the context is sufficient to guide an agent. It omits any when-not-to-use guidance for scenarios like needing page text extraction without element refs.

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 burden. It discloses the read-only nature (returns URL/title) but doesn't mention potential side effects, session/tab behavior, or what happens if the tab is invalid. The behavior is simple enough that this is adequate 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?

One sentence, front-loaded with the action and result. No wasted words.

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

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

The tool is simple and has an output schema, so the description doesn't need to explain return values. However, with no parameter documentation and no usage guidance, an agent might not know how to specify a tab or session. Adequate for a simple getter 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 0%, so the description must compensate. It doesn't explain the 'tab' or 'session' parameters at all, leaving the agent to infer their meaning from names. The description adds no parameter-level 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 clearly states the tool returns the current URL and title of the tab, which is a specific verb and resource. It distinguishes itself from sibling tools like browser_navigate or browser_snapshot, though it doesn't explicitly name them.

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

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

The description implies a read-only informational use case, but it doesn't explicitly state when to use this tool versus alternatives like browser_snapshot or browser_extract_meta. No exclusions or alternative routing 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?

With no annotations provided, the description must carry the full burden. It only mentions a side effect (reveals menus/tooltips) but fails to disclose other behaviors such as whether it waits for elements, how errors are handled, or if it triggers JavaScript events. No mention of potential requirements (e.g., element must be visible).

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

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

The description is very short, which is good for conciseness, but it lacks critical information. It is front-loaded with the verb and resource, but the brevity undermines usefulness. It is not padded, but it does not earn its place by adding value beyond what the name implies.

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 3 parameters and no annotations, the description is inadequate. It does not explain return values despite having an output schema, nor does it specify parameter semantics. The sibling tools are numerous, so more context is needed to select correctly.

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

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

Schema description coverage is 0%, so the description must compensate for all parameters. It only explains 'ref' implicitly (hover by ref) but gives no details on 'tab' or 'session'. With 3 parameters and zero coverage, this is a critical gap.

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

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

The description states a specific verb and resource ('hover over an element by ref') and notes a common effect (reveals menus/tooltips). However, it does not distinguish from sibling actions like browser_click or browser_find, and the purpose is somewhat generic. It is clear enough but lacks 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 gives no guidance on when to use this tool vs alternatives. It does not mention that hovering is needed for dynamic UI elements, nor does it exclude cases where click would suffice. No references to related tools like browser_click or browser_find.

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 discloses that the tool returns the new page state and includes a snapshot when content changes, configurable via NAVIGATOR_AUTO_SNAPSHOT. However, it omits other behavioral aspects such as the meaning of the 'wait' parameter, error handling on invalid URLs, or potential side effects (e.g., triggering dialogs). It adds some value but is not comprehensive.

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 short and front-loaded with the primary action. It is efficient with two sentences and no filler. However, it could have been structured to include parameter details without becoming verbose, so it loses a point for missing that opportunity.

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

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

For a tool with 4 parameters, no annotations, and no schema descriptions, the description is inadequate. It does not explain the 'wait' and 'session' semantics, how to handle failures, or how this tool fits into the broader navigation workflow (e.g., when to use it vs. back/forward). An output schema exists but is not shown; even so, the description should still cover key usage context. The tool is not fully self-explanatory for an agent.

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 only vaguely addresses the 'tab' parameter via 'active (or specified) tab' and implicitly covers 'url'. The 'wait' and 'session' parameters are completely unexplained, and there is no guidance on valid values or behavior. This leaves the agent guessing about half the parameters.

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

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

The description clearly states the action ('Navigate'), the resource ('the active or specified tab'), and the target ('to a URL'). This distinguishes it from siblings like browser_navigate_back/forward (history navigation) and browser_reload (refresh), so an agent can immediately tell what this tool does.

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

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

The description implies usage (when you want to go to a URL) but provides no explicit guidance on when to choose this tool over alternatives like browser_navigate_back, browser_navigate_forward, or browser_reload. It does not mention when not to use it or any prerequisites, leaving the choice 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 provided, the description must carry the full burden of behavioral disclosure. It only states the action, but does not disclose what happens if there is no history (e.g., error or no-op), whether the navigation waits for page load, how it affects the current snapshot, or any side effects on the browser state. This is a significant gap for a navigation tool.

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

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

The description is a single sentence with no fluff, which is concise and front-loaded. However, it is under-specified: it omits crucial usage and behavioral details. While conciseness itself is good, the lack of substance makes it barely adequate. It earns its place but does not fulfill the information 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?

Given the tool's complexity (simple navigation) and the lack of annotations, the description is incomplete. It does not cover edge cases (e.g., no history), parameter semantics, or when to choose this over forward/reload. Even though an output schema exists (not shown), the description fails to provide enough context for an agent to invoke it correctly in all situations.

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 two parameters (tab and session) with zero description coverage, and the description does not explain either. It only says 'in the tab', which vaguely hints at the tab parameter but provides no meaning for what tab accepts (integer or null) or what session does. The agent cannot infer parameter usage from the description.

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

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

The description clearly states the action: 'Go back one history step in the tab.' It identifies the verb (go back) and the resource (history step in the tab), which distinguishes it from siblings like browser_navigate_forward and browser_reload. However, it could be slightly more specific about the scope (e.g., which tab/session), but the core purpose 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. It does not mention browser_navigate_forward for going forward, nor does it explain conditions like having history to go back to. The description leaves the selection entirely to the agent without any contextual cues.

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 of behavioral disclosure, but it only states the core action. It does not mention side effects, behavior when there is no forward history, page-load waiting, or whether the current tab's state is altered beyond history position.

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 with no filler. It front-loads the action and scope ('forward one history step in the tab') with zero waste.

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-step navigation tool, the description is minimally adequate, but it omits usage conditions, parameter meaning, and failure behavior. The output schema covers return values, yet the overall definition lacks enough context for an agent to use it with confidence in edge 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 0%, so the description must compensate, but neither 'tab' nor 'session' is mentioned. The parameter names are somewhat self-explanatory and optional, yet the tool invocation semantics (e.g., what a null tab means) are left entirely 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?

The description uses a specific verb ('Go forward') and a specific resource ('one history step in the tab'), making the action unambiguous. It naturally distinguishes itself from the sibling browser_navigate_back by stating the direction of navigation.

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 for when to use this tool versus browser_navigate_back, browser_navigate, or browser_reload. The only hint is the word 'forward', which implies history navigation, but no exclusions, prerequisites, or alternatives 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that blocking applies 'across all sessions' and uses URL globs, which is useful. However, it does not disclose whether the blocking is immediate, whether it requires a page reload to take effect, whether it is reversible, or any side effects (e.g., breaking pages that depend on blocked resources). Given the lack of annotations, 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 succinct: two sentences and an example list. The core purpose is front-loaded in the first sentence, and the examples are immediately actionable. There is no fluff or repetition. Every word earns its place.

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

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

For a simple tool with one parameter and an output schema, the description covers the essential aspects: what it does, how to specify the globs, and a typical use case. It does not mention reversibility (unblocking) or potential side effects, but given the tool's simplicity and the presence of an output schema, this is a minor gap. Overall, it is adequately complete for an agent to call it correctly.

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

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

The schema has only one parameter, url_globs, with no description in the schema itself (0% coverage). The description compensates by explaining the glob format and providing concrete examples (e.g., ['**/*.css', '**/ads.js']). This gives the agent clear guidance on what values to provide, well beyond the raw schema.

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

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

The description states a specific verb and resource: 'Block requests matching URL globs across all sessions.' It clearly identifies the action (blocking), the target (requests), and the scope (all sessions). It also gives concrete examples of glob patterns and the intended use case (blocking ads/trackers to speed up automation). This makes the tool's purpose unambiguous and distinguishes it from siblings like browser_network_unblock.

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

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

The description implies usage ('Blocks ads and trackers to speed up automation dramatically') but does not explicitly state when to use this tool versus alternatives such as browser_network_unblock or browser_network_capture_start. There is no mention of when not to use it or how it interacts with other network-related tools. The guidance is implicit rather than explicit, so a middle score is appropriate.

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

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

No annotations are supplied, so the description carries the full burden of disclosing side effects. It reveals the default-all behavior and tab scope, but omits what clear does, how session scopes the recording, and that the capture remains active until browser_network_capture_stop. For a stateful tool these are significant undisclosed behaviors.

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

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

The description is two short sentences, front-loads the core action, and uses a compact list for the filters. There is no filler and 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?

An output schema exists, so return values need no explanation, but the context is incomplete for a 6-parameter stateful tool with zero annotations. Missing lifecycle/session semantics and the unexplained clear parameter mean an agent could make incorrect assumptions about capture scope and side effects. This is a material gap, not a minor one.

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 for the input schema. It adds useful semantics for resource_types (with examples), url_contains (substring), and methods (GET/POST), but says nothing about tab, clear, or session, including the impactful clear default. The compensation is partial at best.

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 concrete verb-object pair ('Start recording network requests') and scopes it to 'this tab', which distinguishes it from siblings like browser_network_capture_stop, browser_network_list, and browser_network_get. It does not just restate the tool name.

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 invocation context: optional filters and the default 'records everything', so an agent knows the capture starts unfiltered if filters are omitted. However, it never states when to choose this over sibling network tools (get/list/block/unblock) or how it fits into the capture lifecycle, leaving that 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 full responsibility. It discloses one behavioral trait: the buffer is kept until the next start, which indicates that stopping does not discard collected data. However, it does not mention effects like whether stopping clears the buffer, what happens if no capture is active, or any side effects. The disclosure is minimal but not contradictory.

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

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

The description is a single concise sentence that front-loads the action and includes a useful parenthetical about buffer behavior. There is no filler or redundancy; every part serves a purpose.

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

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

Given that the tool has no annotations and zero parameter documentation, the description is incomplete. It does not explain the role of 'tab' or 'session', nor does it specify conditions like 'use only after a capture has started'. While an output schema exists, the lack of parameter semantics and explicit usage context leaves the agent with insufficient information for correct invocation in varied scenarios.

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

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

Schema description coverage is 0%, and the description makes no mention of the 'tab' and 'session' parameters. Since the schema itself likely provides only types and defaults, the description must add meaning to help the agent choose values, but it fails to do so. This is a significant gap.

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

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

The description clearly states a specific verb ('Stop recording network requests') and resource ('network requests'), and it directly contrasts with the sibling 'browser_network_capture_start' by indicating the stopping action. It is unambiguous and distinguishes itself from other network 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?

Usage is implied by the name and the parenthetical about buffer retention, but there is no explicit guidance on when to use this tool versus alternatives (e.g., when to stop a capture session) or any exclusions. The description does not mention prerequisites like a prior capture start, leaving the agent to infer the appropriate context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions 'full details + response body' but does not state what happens with an invalid index, whether capture must be running, potential side effects, or error handling. Minimal behavioral context beyond the literal function.

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 concise sentence that front-loads the core action and resource. There is no wasted verbiage; every word contributes to understanding the tool's purpose.

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

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

Despite a simple tool, the description is incomplete. It lacks guidance on how to obtain the index (e.g., from browser_network_list), whether capture must be active, and the semantics of tab and session. The output schema covers return values, but the missing operational context leaves the agent uncertain about correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that 'index' selects the captured request, but it does not explain 'tab' or 'session' parameters at all. The description adds only marginal value over the bare parameter names, failing to compensate for the coverage gap.

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

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

The description clearly states the action (fetch), the resource (full details + response body of a captured request), and the selection mechanism (by index). It differentiates from siblings like browser_network_list, which likely provides summaries, and browser_network_capture_start/stop, which manage capture.

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

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

No guidance on when to use this tool versus alternatives. It does not mention that the index should come from browser_network_list, that capture must be active, or any prerequisites. The description is silent on exclusions and alternatives, leaving the agent to infer the context.

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

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

With no annotations provided, the description carries the full burden. It discloses the ordering behavior ('most recent first') and implies a read-only operation ('List'), but doesn't mention whether this returns all captured requests across tabs/sessions, whether it requires an active capture session, or what happens when no requests have been captured. The output schema exists but the description doesn't clarify the data scope or lifecycle.

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

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

The description is a single concise sentence that front-loads the core action and resource. It's efficient and easy to parse, though it could add a bit more context without becoming bloated.

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 4 parameters, no annotations, and 0% schema description coverage, so the description needs to carry more weight. It explains the basic purpose but leaves out parameter semantics, data scope, and relationship to capture lifecycle. An agent could call it with defaults, but would struggle to use the filtering parameters correctly or know what to expect in the output.

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, but it doesn't explain any of the four parameters (n, tab, session, statuses). The parameter names are somewhat self-explanatory, but the description adds zero value for understanding filtering semantics, defaults, or how they interact. This is a significant gap for a tool with 4 parameters and no schema descriptions.

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

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

The description states a specific verb ('List') and resource ('captured network requests') with a clear ordering ('most recent first'). It distinguishes itself from sibling tools like browser_network_get (which likely retrieves a single request) and browser_network_capture_start/stop (which control capture), though it doesn't explicitly name them.

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

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

The description implies this is for reading previously captured network requests, and the 'most recent first' ordering suggests a log-viewing use case. However, it doesn't explicitly state when to use this over browser_network_get or how it relates to capture start/stop tools. The context is clear enough for an agent to infer basic usage, but no explicit alternatives 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 provided, the description carries the full burden of behavioral disclosure. It does disclose the broad 'all' scope, signaling this is a sweeping destructive action on every blocking rule, which is important context. However, it does not mention reversibility, whether in-flight requests are affected, or whether the action is idempotent.

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 six-word sentence with zero filler. Every word earns its place, and the scoping qualifier 'all' is front-loaded where it matters most.

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 parameterless tool with an output schema present, the description is nearly complete. An agent can correctly invoke it with no arguments. The only gap is the absence of any note about side effects or scope consequences beyond 'all,' which is a minor omission 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?

The tool has zero parameters with 100% schema coverage, so the schema documents everything there is to know. Per the rubric, a zero-parameter tool earns a baseline of 4; the description correctly adds no parameter noise since none exist.

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

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

The description 'Remove all URL blocking rules' states a specific verb (remove) and resource (URL blocking rules), making the purpose immediately clear. It pairs naturally with the sibling browser_network_block as its inverse, though it does not explicitly name that counterpart.

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

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

The description gives no guidance on when to use this tool versus alternatives, no exclusions, and no mention of preconditions. Usage is only implied as the natural undo for browser_network_block, which an agent would have to infer from the sibling list rather than from the description itself.

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, but it only restates the basic action. It does not disclose where the key event is sent, whether it can trigger navigation or form submission, whether modifier combinations like 'Control+a' are supported as written, or whether the page must be focused.

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 useful key examples and no wasted words. It is appropriately concise for the action it names.

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 browser automation tool with three parameters, no annotations, and 0% schema coverage, this description is too sparse. It lacks essential context about target focus, accepted key syntax, modifier behavior, and the meaning of tab/session, so an agent may invoke it incorrectly.

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, but it only adds meaning for 'key' through examples. The 'tab' and 'session' parameters are completely unexplained, leaving the agent to guess how to target a specific tab or session.

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

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

The description clearly states the action ('Press') and the resource ('a key'), with concrete examples (Enter, Escape, Tab, ArrowDown, Control+a) that make the keyboard nature unmistakable. This distinguishes it from the many mouse-oriented siblings like browser_click and browser_fill.

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_click_text, browser_fill, or browser_hover. It does not mention focus requirements, page state, or scenarios where a key press is the appropriate interaction.

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 reading is non-destructive unless drain=true, which clears the buffer, a useful behavioral trait. However, it does not describe return format, pagination, whether it blocks, or potential side effects beyond drain. For a read operation, this is adequate but not rich; it lacks context like what happens if the buffer is empty or whether errors are aggregated.

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

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

The description is two sentences with zero waste. The primary purpose is front-loaded in the first sentence, and the drain behavior is added as a separate line. Every word earns its place, making it highly efficient and scannable.

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

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

Given 4 parameters, an output schema, and no annotation coverage, the description is incomplete. It lacks details on n, tab, and session semantics, and does not clarify the nature of the output (e.g., whether it returns structured logs, timestamps, or just text). While the output schema may cover return structure, the parameter gaps and lack of behavioral context leave the agent guessing on how 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 description coverage is 0%, so the description must compensate for all parameters. It only explains drain (to clear the buffer), leaving n (likely number of messages), tab (which tab), and session (which session) completely unexplained. The agent has no idea what n controls (count? index?), how tab selection works, or session context. This is a significant gap for a 4-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 clearly states the verb 'Read' and the resource 'console messages and page errors', listing specific types (JS errors, logs, failed asserts). It distinguishes the tool's core function from sibling tools like browser_network_get (network) or browser_read_dialogs (dialogs) through its focus on console, though it doesn't explicitly name any alternative. This is clear but not overtly differentiated.

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

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

The description gives a concrete usage tip: 'Set drain=true to clear the buffer after reading.' This implies when to use the drain parameter but does not provide guidance on when to use this tool versus alternatives, nor any conditions or prerequisites. The hint about drain is helpful but leaves the broader usage context implicit.

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 burden of behavioral disclosure. It only states 'Read captured...' without explaining whether reading consumes the dialogs, what happens when no dialogs exist, or how the n parameter affects behavior. This is a significant gap for a tool that likely manipulates a queue.

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 words. It states the core action and target efficiently.

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

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

Given the presence of three parameters and an output schema, the description is too sparse. It lacks parameter explanations, behavioral details, and usage context. While the tool may be straightforward, the complete absence of parameter or behavioral info makes it inadequate 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 input schema has 0% description coverage, yet the description does not explain any of the three parameters (n, tab, session). The parameter names are suggestive but not explicit, and the description adds no clarification about their semantics, leaving an agent to guess their meanings.

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

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

The description states a clear verb ('Read') and resource ('captured alert/confirm/prompt dialogs'), making the tool's purpose unambiguous. It is distinct from siblings like browser_dialog_respond (which likely writes) and browser_set_dialog_mode (which configures handling), though it does not explicitly differentiate itself.

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

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

The description provides no guidance on when to use this tool versus alternatives such as browser_dialog_respond or browser_set_dialog_mode. It is implied that reading is appropriate when dialogs have been captured, but no explicit conditions 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 must disclose behavioral traits. It only states the action without mentioning side effects (e.g., losing form data, resetting JavaScript state, whether it waits for page load). It also ignores the tab and session parameters, which could affect behavior.

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, direct sentence that front-loads the action. It has no wasted words. However, it is under-specified, omitting essential usage and parameter context, so while concise, it is not as helpful as it could be.

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

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

Despite being a simple tool, the description is incomplete. It doesn't explain when to use it, what the parameters do, or any caveats. The output schema exists but the description doesn't clarify the operation's scope or effects, leaving the agent under-informed.

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 says nothing about the 'tab' or 'session' parameters. An agent cannot infer their meaning, defaults, or interaction from the text, so the description adds no value over the bare schema.

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

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

The description states a specific verb ('Reload') and a specific resource ('the current page'). It clearly distinguishes from sibling tools like browser_navigate (loads a new URL) and browser_navigate_back/forward, so an agent can tell it apart.

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 reload vs. navigate, back, or forward. It doesn't mention scenarios like refreshing after a change or handling stale content, nor does it exclude alternatives. The agent is left to infer usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds only 'Chromium only' and 'current page', but does not explain what happens to the target path, whether files are overwritten, how tab/session selection affects the page, or what the result contains.

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 words. However, it is so terse that it under-serves a five-parameter tool, so it loses a point for appropriateness of size.

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

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

Given no annotations and 0% schema description coverage, the description is far from complete. It covers the tool's basic purpose but omits parameter semantics, file-handling behavior, and any usage context, leaving an agent to guess critical details before 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%, so the description must compensate by explaining the parameters. It does not mention path, format, print_background, tab, or session, leaving all five parameters unexplained beyond their raw names.

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

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

The description states a specific action ('Save the current page'), a specific output format ('PDF'), and an explicit constraint ('Chromium only'). This clearly differentiates it from sibling tools like browser_screenshot, which captures an image rather than a PDF.

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

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

The description gives no guidance on when to prefer this tool over alternatives such as browser_screenshot or extract tools. The 'Chromium only' note is a compatibility restriction, not usage context, and there are no prerequises or when-not-to-use conditions 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 burden of explaining behavior. It discloses the output type (image) and area/format behaviors, including that 'element' requires ref. It does not mention potential side effects, limitations on full-page captures, or how the image is returned (e.g., base64, path), but screenshot operations are inherently low-risk reads.

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-loads the main action, and uses line breaks to separate parameter guidance. Every sentence adds useful information without filler or repetition of the schema.

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 the basic default use case, the description is sufficient: calling with no arguments will take a viewport screenshot in PNG. However, with 6 parameters, no output schema, and no annotation coverage, the description leaves important gaps around ref semantics, quality, session, and tab selection that an agent may need for correct advanced usage.

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

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

Schema description coverage is 0%, so the description must compensate. It usefully explains 'area' and 'format' with values and trade-offs, but it leaves 'ref', 'tab', 'quality', and 'session' largely undocumented. 'ref' is only mentioned as 'requires ref' without defining what it should refer to, and 'quality' has no explanation at all.

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

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

The description clearly states the verb and resource: 'Take a screenshot and return it as an image.' This is unambiguous and distinct from sibling extraction or navigation tools. However, it does not explicitly differentiate itself from browser_snapshot, which could be confused as an alternative visual capture.

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 practical guidance on choosing area and format, including 'prefer it for large pages.' It also hints at the intended audience ('for vision-capable LLMs'). However, it does not explicitly state when to use this tool over alternatives like browser_snapshot or browser_extract_text.

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

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

No annotations are provided, so the description must carry full behavioral disclosure. It does not mention whether the scroll is smooth or instant, what happens when both direction and amount_px are supplied, whether it affects page state, or any side effects. This leaves important behavioral ambiguity for an agent.

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

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

The description is two sentences with no filler. It front-loads the core action ('Scroll the page') and then succinctly lists the key options. Every word contributes to understanding.

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

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

For a tool with four parameters, no annotations, and no in-schema parameter descriptions, this description is too sparse. It does not explain the tab/session parameters, the semantics of combining direction with amount_px, or any return behavior, even though an output schema exists. An agent would need to infer or experiment to use 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?

With 0% schema description coverage, the description must explain all parameters. It only addresses direction (listing the allowed values) and amount_px (as 'Optional pixel amount'), but completely ignores the tab and session parameters. The interaction between direction and amount_px is also not clarified, leaving the agent without full parameter understanding.

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

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

The description states a specific verb and resource ('Scroll the page') and clarifies the scope by listing the four directional variants (down, up, top, bottom) plus an optional pixel amount. No sibling tool performs scrolling, so this is easily distinguishable.

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

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

There is no explanation of when to use this tool versus other browser tools, no prerequisites, and no mention of situations where it should not be used. The description only states what it does, leaving the agent to infer use cases from the name and sibling 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 present, so the description alone must disclose behavior. It adds one meaningful behavioral fact: the submitted value is the visible option label, not the option's internal value attribute. It stops short of saying whether selection triggers side effects, clears prior selections, or errors on no matching option.

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

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

Two short sentences, each carrying distinct information and no filler. The core action is front-loaded, with the parameter caveat second. This is appropriately concise.

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 UI mutation, the core usage is stated, and the output schema covers return expectations. However, the description omits usage boundaries and any behavioral caveats, and it relies on the agent already knowing how `session`/`tab` work. It is adequate for the happy path but not fully self-contained.

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 is bare (0% coverage), and the description partially compensates by explaining that `value` is the option label and that selection is by `ref`. `tab` and `session` receive no semantic explanation, leaving the agent to rely on defaults or conventions. For a low-coverage schema this is only partial compensation.

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?

Identifies a distinct operation: selecting an option in a dropdown/combobox using a ref. The parenthetical 'combobox' and the phrase 'Value = option label' clarify the resource and selection criterion. It doesn't explicitly name a sibling alternative, but the resource is specific enough to separate it from click/fill tools.

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

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

The description implies the right scenario: when an agent needs to choose an item from a dropdown that was located by ref. It gives no explicit guidance about when not to use it or which sibling to prefer, so the agent must infer the boundary from the verb and resource. With many browser interaction siblings, this is a usable but implicit hint.

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 burden. It discloses the destructive side effect (cookies/storage discarded) and the exception (unless saved). This is valuable beyond the schema. It does not mention reversibility or permissions, but the primary behavioral trait 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?

A single, front-loaded sentence states the primary action, followed by a parenthetical that adds essential behavioral context. No wasted words; it is clear and compact.

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

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

Given the tool's simplicity (one parameter, output schema present), the description is mostly complete. It covers the key side effect. It does not describe error conditions or what the output contains, but since an output schema exists, that is less critical. The missing parameter explanation is a gap, but the overall context is adequate.

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

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

Schema coverage is 0% and the description does not explain the 'name' parameter. The agent must infer that 'name' refers to the session identifier. The description only says 'Close a session' without connecting it to the parameter, so it fails to compensate for the missing schema documentation.

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

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

The description clearly states the action: 'Close a session and all its tabs.' It specifies the resource (session) and scope (all its tabs), which distinguishes it from browser_tab_close that closes a single tab. The cookie/storage note further clarifies behavior.

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 this is for closing an entire session but does not explicitly compare to alternatives like browser_tab_close. It does mention the prerequisite of saving auth with browser_session_save_auth to preserve cookies/storage, offering some contextual guidance, but no explicit 'use this when' or 'don't use this when'.

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 burden. The verb 'List' implies a read-only operation, but it does not explicitly state that it has no side effects, requires no authentication, or has any limitations. Since it returns session data, it effectively discloses its non-mutating nature, but it lacks explicit statements about side effects or conditions.

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

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

One sentence, no filler, and the key information (listing active sessions) is front-loaded. Every word adds value, and it is appropriately terse for a simple list operation.

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 fully covers what the tool does and what it returns. A structured output schema exists, so the exact return format is already specified. For a no-argument list tool with low complexity, the description is complete—nothing an agent needs to call it correctly 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 schema is trivially 100% covered. Per the baseline for 0-parameter tools, the description does not need to add parameter details. The description does not mention parameters, which is appropriate given there are none.

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

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

The description clearly states a specific verb ('List') and resource ('all active sessions') and explicitly enumerates the data included (tabs, fingerprints, proxies). This is unambiguous and distinguishes it from sibling tools like browser_session_new or browser_session_close, which have different purposes.

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

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

The description implies usage (use this to see active sessions) but does not provide explicit when-to-use guidance or contrast with alternatives like navigator_status. It is a simple list tool, so the purpose itself suggests when to use it, but no explicit exclusions or sibling differentiation are offered.

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 of behavioral disclosure. It explains parameter effects (stealth, profile, proxy, etc.) but does not describe what happens after creation: whether the new session becomes active, what is returned (session ID?), or side effects on the current session. The overall behavior of the tool beyond parameter settings is 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?

The description is a single sentence followed by a bulleted list, front-loaded with the core purpose. Each parameter is given a brief, explanatory note with no extraneous words. The structure is clean and scannable, making it easy for an agent to quickly grasp the key options.

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 (10 parameters, no annotations), the description is insufficient. It does not explain the lifecycle of a session—how it is activated, how it relates to other session tools (e.g., browser_session_list, browser_session_close), or that a session must exist before using navigation tools. The output schema exists, so return values are covered, but the overall workflow and prerequisites are missing.

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

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

Schema coverage is 0%, so the description must compensate. It explains six parameters (stealth, profile, proxy, fingerprint, bypass_csp, record_har) with clear semantics, but leaves four parameters (name, locale, timezone, geolocation) unexplained. While these are somewhat inferable from names, the geolocation object and locale/timezone formatting are not detailed. The description adds meaningful value for most parameters but does not fully cover all.

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

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

The description clearly states the tool creates a new isolated browser session. The verb 'create' and the resource 'isolated browser session' are specific, and the term 'isolated' differentiates it from tab-level operations like browser_tab_new. The purpose is unambiguous and distinct from sibling tools such as browser_session_list or browser_session_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 provides no guidance on when to create a new session versus reusing an existing one, nor does it mention any alternatives. It only lists parameters without explaining the typical workflow (e.g., that a session must be created before navigation). No exclusions or conditions are given, leaving the agent to infer usage from context.

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

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

With no annotations, the description carries the behavioral burden. It discloses that cookies and localStorage are persisted and that the profile survives restarts, which is valuable. However, it does not disclose whether an existing profile is overwritten, merged, or rejected, nor any side effects on the current session.

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

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

The description is two tight sentences with the core action front-loaded and the restore workflow stated immediately after. Every sentence adds useful information 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?

Although the output schema exists and the core purpose is clear, the description is not complete enough because one of two required parameters ('name') has no semantic guidance. It also omits overwrite/duplicate behavior, which matters for a persistence operation on named profiles.

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

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

Schema description coverage is 0%, so the description must explain both required parameters. It clarifies profile_name through the restore example, but the 'name' parameter is completely unexplained and not even mentioned in the description, leaving a critical 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?

The description uses a specific verb ('Persist') and resource ('cookies + localStorage') and clearly states the output is a named profile. It also names the restore counterpart, browser_session_new, which distinguishes it from sibling session management tools.

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

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

It gives clear usage context: save the session for later restores, especially 'for staying logged in across engagements.' It mentions the restore mechanism via browser_session_new, but does not explicitly state when not to use this tool or call out alternative save/load approaches.

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 auto accepts and records dialogs, and manual pauses them for response. It doesn't mention side effects like whether switching modes clears queued dialogs or if the setting persists across sessions, but the core behavior is clearly stated for a simple setter.

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

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

The description is a single, concise sentence that front-loads the purpose and explains both modes with zero wasted words. It is perfectly structured for quick comprehension.

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, but the description omits any explanation of the 'tab' and 'session' parameters, which are present in the schema. It also doesn't clarify whether the mode applies globally or per-tab. Given the lack of annotations and 0% schema coverage, the description should compensate for these gaps, but it only covers the mode parameter. This is a notable gap for a complete definition.

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

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

The description adds meaning to the 'mode' parameter by explaining the two valid values and their effects, which the schema lacks (0% schema coverage). However, it does not address 'tab' or 'session' parameters at all, leaving them unexplained. Since mode is the primary parameter and tab/session have defaults, this is partial but not complete compensation.

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 (Set dialog handling) and precisely defines the two modes with their effects ('auto' accepts and records, 'manual' pauses for browser_dialog_respond). This clearly differentiates it from siblings like browser_dialog_respond and browser_read_dialogs, which handle or read dialogs.

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 that manual mode pauses dialogs so browser_dialog_respond can answer them, giving a clear use case for when to choose manual. However, it doesn't explicitly contrast with auto mode beyond noting it's the default, nor does it discuss other alternatives or when to avoid this tool. The implication is present but not fully explicit.

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

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

With no annotations, the description carries the full behavioral burden, and it does well: it discloses an internal cached-snapshot behavior ('returns a short unchanged notice instead of re-sending the tree'), the stability of refs across snapshots, and the exact effect of force ('always re-render') and deep ('include child frames'). It omits side-effect details, but as a read-style capture tool the disclosed behaviors are the ones that matter for invocation.

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?

Three sentences, zero waste. Purpose is front-loaded first, followed by the ref mechanism, the caching behavior, and parameter flags. Every sentence earns its place and the token-savings note is a high-value addition 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?

Given the tool has an output schema (so return shape need not be spelled out) and moderate complexity, the description is nearly complete: it covers output behavior, refs, caching, and both behavioral flags. The only real gap is the omitted tab and session parameter semantics, which is minor since both have schema defaults and are common suite-wide patterns.

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 explicitly explains force=true and deep=true, covering half the parameters with real semantics. However, tab and session are left completely unexplained, and the schema provides no descriptions either, leaving an agent to infer their meaning from sibling-tool conventions.

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+resource: 'Capture the page as a compact, ref-annotated accessibility snapshot.' It further distinguishes itself from extraction siblings (browser_extract_text/html, browser_screenshot) by explaining the ref mechanism ('Elements get stable refs (e.g. [ref=e12]) that interaction tools accept'). An agent can clearly tell this is an accessibility-tree capture, not a text, HTML, or visual snapshot.

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 clear usage context: use this when you need stable refs for interaction tools, and it advertises a major efficiency benefit (token savings via the 'unchanged' notice). It does not explicitly name alternatives or state when not to use it, but the benefit framing alone gives an agent enough signal to select it over screenshot/extract siblings.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose an important edge-case behavior: the active tab cannot be closed when it is the last tab. However, it does not explain what happens after closing a tab, how session relates to the operation, or how invalid indices are handled.

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. The parenthetical adds a genuinely useful behavioral constraint without bloating the text. 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?

Despite the tool's apparent simplicity and existing output schema, the description is not complete enough for correct invocation. The meaning of the required 'index' parameter and the optional 'session' parameter is entirely unexplained, and the relationship between the 'active tab' restriction and the index parameter is ambiguous.

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 needed to explain what 'index' and 'session' mean, but it does not mention either parameter. An agent is left to guess whether index is 0-based, which tab it targets, and what session scope applies. This is a significant gap because the schema itself provides only types and defaults, no semantic meaning.

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

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

The description uses a specific verb ('Close') and resource ('tab'), making the core operation unambiguous. It also adds a key constraint (the active tab cannot be the last one), which helps distinguish this from tab-list, tab-new, and tab-select siblings, though it does not explicitly state that closing is by index.

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

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

The description gives a clear context: use this when you need to close a browser tab. It also provides an exclusion by noting that the active tab cannot be closed if it is the last tab. It does not mention alternatives or prerequisites such as using browser_tab_list to obtain an index, but the intended use case is still fairly clear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only says it lists tabs with URLs; it doesn't disclose whether it returns tab IDs, active tab status, or whether it creates a session if none exists. For a read-only listing tool, the lack of detail about the output structure and side effects is a gap, though the operation is inherently low-risk.

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

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

The description is a single concise sentence that front-loads the action and resource. It is appropriately sized for a simple tool. It could add a bit more detail about the output, but it doesn't waste words.

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

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

The tool has an output schema, so return values are presumably documented there. The description is minimal but sufficient for a simple listing operation. However, with no annotations and no usage guidance, an agent might not know whether the session parameter is required or what happens if the session doesn't exist. Given the tool's simplicity, this is a minor gap, but the description could be more complete.

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

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

Schema description coverage is 0%, so the description must compensate. The description mentions 'a session' which maps to the 'session' parameter, but it doesn't explain the default value behavior or what values are valid. The parameter is optional with a default, so the description's mention of 'a session' is adequate but minimal. Baseline 3 is appropriate because the description adds some context but doesn't fully explain the parameter semantics.

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

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

The description states a specific verb ('List') and resource ('tabs of a session') and mentions the output includes URLs. It is clear what the tool does. However, it doesn't explicitly distinguish itself from sibling tools like browser_tab_new, browser_tab_select, or browser_tab_close, though the name and description make the distinction fairly obvious.

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

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

The description implies usage: call this when you need to see the tabs in a session. It doesn't explicitly state when to use it versus alternatives like browser_tab_select or browser_session_list, nor does it mention any prerequisites (e.g., a session must exist). The context is clear enough for a simple listing tool, but there is no explicit 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 burden of behavioral disclosure. It explicitly states that the new tab becomes active, which is a state change. However, it does not mention side effects such as how the session parameter affects behavior or any potential failures (e.g., tab limits). It covers the core mutating behavior adequately.

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

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

The description is a single, well-structured sentence with no redundant words. It front-loads the primary action and incorporates the optional navigation in a natural clause, achieving high readability and efficiency.

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 two parameters and the existence of an output schema, the description is mostly complete for the action itself. However, it lacks any explanation of the 'session' parameter, which is relevant given sibling tools like browser_session_new. The agent may not know how to correctly use or omit the session without additional context, making it incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'url' parameter implicitly via 'optionally navigating it to a URL', but completely ignores the 'session' parameter. Since the schema provides no descriptions and the tool description only clarifies one of two parameters, the compensation is partial.

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

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

The description states a clear verb 'open a new tab', a specific resource (a tab), and a secondary action (navigate to a URL, make it active). It clearly differentiates from siblings like browser_tab_close, browser_tab_select, and browser_navigate by focusing on creation and activation.

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

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

The description implies usage for creating a new tab but does not explicitly contrast it with alternatives like browser_navigate (which navigates the current tab) or browser_tab_select (which selects an existing tab). No when-to-use or when-not-to-use guidance is given, leaving some 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?

With no annotations, the description must supply behavioral context; it does state a persistent side effect—'subsequent tools act on it'—which tells the agent that the selection changes the target of later calls. It does not disclose error behavior for invalid indices or confirm whether the operation is non-destructive, so more depth would help.

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 entire description is one short sentence and gets the key information up front. There is no filler, no restatement of the tool name, and the parenthetical adds essential behavioral context 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 description is enough to understand the high-level purpose, but for a correct invocation you still need to know how to obtain a valid `index` and what `session` means; those are absent. The presence of an output schema reduces the need to describe return values, so the main gap is around parameter sourcing.

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 says nothing about the `index` or `session` parameters beyond the word 'tab'. An agent cannot tell how indices are ordered, whether they are 0-based, or how `session` relates to the default session.

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 phrase 'Make another tab active' is a specific verb-resource statement, and the parenthetical 'subsequent tools act on it' clarifies the operational effect. It clearly separates this from siblings like browser_tab_close, browser_tab_new, and browser_tab_list, even though it does not name them.

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

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

The parenthetical gives a concrete usage context: call it before other browser tools when you want those tools to target a different tab. It does not explicitly state when not to use it, but the intended position in a sequence of browser actions is clear.

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

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

With no annotations, the description must carry the behavioral burden. It only says 'Upload a local file' without disclosing side effects, error conditions, or any requirements (e.g., whether the path must exist, what happens on failure). This is insufficient for a mutating action.

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

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

The description is extremely short and front-loaded with the core action, which is concise. However, it's under-specified to the point of being unhelpful, sacrificing necessary detail 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 tool with 4 parameters (2 required), no parameter documentation, and no behavioral details, the description is inadequate. Even though an output schema exists, the agent cannot confidently invoke this tool without knowing what 'path' expects or how errors are handled.

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 'ref' (points to file input or trigger button) but leaves 'path', 'tab', and 'session' unexplained. The description adds minimal value for the other three parameters.

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

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

The description clearly states the tool uploads a local file, and mentions 'Ref' can point to the file input or trigger button. It distinguishes itself from siblings like browser_fill and browser_click because it's the only upload tool, though it doesn't explicitly name alternatives.

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

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

No guidance is provided on when to use this tool vs alternatives, prerequisites (e.g., file existence, element visibility), or exclusions. The intended context is implied 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?

The description discloses that the tool actively waits and can stop on text, selector match, or elapsed time, which is real behavioral content. However, with no annotations available, it omits important behavior such as what happens when no condition is met before timeout_ms, whether it throws or returns, and whether 'selector matches' means exists, visible, or something else.

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 wastes no words and clearly enumerates the three wait modes. It is appropriately brief for a simple wait utility, though it could add one clause about timeout behavior without losing conciseness.

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

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

For a tool with six optional parameters, 0% schema coverage, and no annotations, this description is too sparse. The presence of an output schema reduces the need to document return values, but the missing timeout semantics and unclear parameter relationships leave the definition incomplete for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate for six undocumented parameters. It maps 'text', 'selector', and 'time_s' to the three wait modes, but it does not clarify 'tab', 'session', 'timeout_ms', or how parameters interact, such as whether text and selector are alternatives or combined.

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 ('wait') and names three concrete conditions: text appearing, a selector matching, or a fixed time passing. This distinguishes browser_wait_for from sibling tools like browser_find or browser_click, though it does not explicitly name a differentiating sibling.

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

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

No guidance is provided about when to use this tool versus alternatives such as browser_find or browser_snapshot, and there are no exclusions or preconditions. The three wait modes imply a synchronization use case, but the agent must infer the appropriate context on its own.

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 behavioral disclosure. It only lists what is included (version, sessions, scope, providers, limits) and mentions 'one-call' suggesting efficiency, but does not explain what the output looks like (despite an output schema) or any side effects. For a read-only status tool, this is adequate but minimal.

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

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

The description is extremely concise at seven words, front-loading the core purpose ('One-call status') and listing key fields. It is efficient with no waste, though it could benefit from a sentence on return format.

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 status tool with an output schema, the description is fairly complete. It doesn't explain the return structure in detail, but the output schema likely does. Given the simplicity, it covers what an agent needs to know for 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 tool has zero parameters, so the description need not explain any. The schema coverage is 100% (vacuously), and the description adds context about what the call returns, which is helpful. A baseline of 4 is appropriate for zero-parameter tools.

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