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

Annotations indicate no destructive or read-only behavior, but the description adds crucial context: 'attaching exposes the live browser context and any data visible in the selected tab.' This goes beyond annotations and informs the agent of side effects and authorization needs.

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

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

The description is three sentences with clear structure: use case, prerequisites/next steps, and sensitivity warning. No redundant information, though the sensitivity sentence could be integrated but remains efficient.

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

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

Given 6 parameters and 0% schema coverage, the description covers the core purpose, selection criteria, and important behavioral notes. It references an output schema so return values are handled. Missing minor details like the format of cdpUrl, but overall sufficient for agent decision-making.

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 mentions several selection parameters (pageId, urlContains, titleContains, targetIndex) and the required cdpUrl, but does not explain the 'activate' parameter. Partial coverage, not fully compensating 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 clearly states the verb 'attach' and the resource 'Chromium page'. It specifies that it connects to an already-running instance and selects a tab by various criteria, distinguishing it from sibling tools like browser_launch and browser_switch_tab.

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

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

The description explicitly states when to use (already-running Chromium with a page to diagnose) and provides preconditions (authorized CDP endpoint) and next steps (confirm with browser_get_state). It does not explicitly list alternatives or when not to use, but the context is clear enough.

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

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

Annotations already mark as destructive and not read-only. The description adds value by detailing sensitivity: can submit data, mutate remote state, expose traces. This provides context beyond the annotation flags.

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?

Four sentences, each serves a purpose: purpose, preconditions, next steps, side effects. No wasted words, front-loaded with critical usage context.

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

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

With 3 parameters, destructive hint, and output schema present, the description covers usage and side effects but omits parameter details and default behavior (e.g., what happens when 'checked' is omitted). Adequate but not comprehensive.

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 parameters. It does not mention selector, checked, or timeoutMs. The purpose hint (checkbox/radio) is weak compensation. Agents would need additional 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 clearly states the tool is for checking or unchecking checkbox/radio controls, using specific verbs and resource. It distinguishes from sibling tools like browser_click or browser_type by focusing on the specific control type.

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

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

The description gives clear context for when to use (checkbox/radio) and preconditions (active page, precise selector). It doesn't explicitly exclude other input types but the purpose is narrow enough. Sibling tools cover other interactions.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds valuable context: 'clearing cookies can sign out accounts and irreversibly remove session state from the active context.' This goes beyond annotations and helps the agent understand the impact.

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

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

The description is three sentences, each serving a distinct purpose: use case, preconditions/next step, and sensitivity. It is front-loaded and concise, though it could be more structured by explicitly listing parameters.

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 complexity (5 parameters, destructive, no schema descriptions), the description is incomplete. It does not explain parameter roles or how filter combinations affect behavior. The output schema exists, so return values don't need explanation, but the lack of parameter guidance leaves 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?

With 0% schema description coverage, the description must explain parameters. It mentions 'filters should be as narrow as possible' but does not explain the name, path, or domain parameters. It states acknowledgeRawCapture and acknowledgeCredentialAccess are required but omits what they mean or why they're needed. This is insufficient.

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 use case: 'Use when a full-profile test needs a deliberate logged-out or clean-cookie state.' It specifies the verb (clear) and resource (browser cookies), and distinguishes from siblings like browser_get_cookies by focusing on the destructive 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 provides explicit when-to-use guidance ('Use when...'), preconditions ('acknowledgeRawCapture: true and acknowledgeCredentialAccess: true are required'), and a next step ('reproduce the intended authentication or redirect behavior after clearing'). It also advises narrowing filters.

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

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

Annotations already indicate destructiveHint=true, so the description adds value by enumerating specific side effects (submit forms, mutate data, navigate, download files, trigger external effects). No contradiction with annotations.

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

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

The description is concise at 4 sentences, front-loaded with the primary use case. Every sentence adds necessary 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?

Given the tool's complexity (potential destructive side effects), the presence of an output schema reduces the need to describe return values. However, the complete lack of parameter documentation makes the description less useful 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?

Schema description coverage is 0%, yet the description provides no details about parameters. It mentions 'precise selector' in preconditions but does not explain the selector parameter format, validity, or the timeoutMs parameter. 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 explicitly states the tool's purpose: clicking a known element during a traced multi-step reproduction. It uses specific verbs and resource ('click element') and differentiates from sibling tools like browser_observe_action_result.

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 clear when-to-use conditions (known element, multi-step reproduction) and when-not-to-use (when outcome uncertain, prefer browser_observe_action_result). It also lists preconditions (active page, precise selector).

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

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

Beyond the destructiveHint annotation, description adds crucial context: closing destroys the in-memory browser context and can discard unsaved page state, plus interaction with monitor flushing.

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 concise sentences, each serving a distinct purpose: purpose, preconditions, and sensitivity. No redundancy or fluff.

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

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

Given no parameters, destructive annotation, and existence of output schema, description provides complete context: purpose, preconditions, and side effects.

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

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

No parameters, so schema coverage is 100%. Description does not need to add parameter info; baseline for 0 parameters is 4.

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

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

Clearly states the tool closes the RawTrace browser context when no longer needed or for resetting. Distinguishes from siblings like browser_close_tab and browser_launch by specifying scope and preconditions.

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?

Explicitly states when to use (context no longer needed or reset needed) and provides preconditions (stop active monitor first if trace must be retained). Implies alternatives but does not name them explicitly.

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 warns that closing a tab discards unsaved in-memory state, which adds value beyond the destructiveHint annotation. It also specifies preconditions to mitigate risks. However, it does not detail the exact consequences (e.g., whether the tab is immediately removed or requires confirmation), so slightly incomplete.

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 (three sentences) and front-loaded with the primary use case. Every sentence adds information. However, the term 'full-profile workflow' could be clarified. Overall well-structured.

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

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

For a simple destructive tool, the description covers purpose, preconditions, consequences, and next steps. The presence of an output schema reduces the need to describe return values. Missing: handling of invalid pageId or when no such tab exists. But overall 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?

The schema provides no description for pageId. The description implies it is the identifier for the tab to close, but does not explicitly define it or specify how to obtain it (e.g., from list_tabs). This leaves 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 clearly states the tool's role: 'remove an unneeded page or recover from a page-specific failure.' This distinguishes it from sibling tools like browser_close (which closes the entire browser) and navigation tools. The title reinforces purpose.

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

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

The description provides explicit when-to-use guidance ('Use when a full-profile workflow must remove an unneeded page...') and preconditions about identifying the page and stopping traces. It also gives next steps. This helps the agent decide when to invoke this tool over 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?

Description adds specifics beyond annotations: 'arbitrary JavaScript can read or modify DOM, storage, page-visible credentials, and remote application state.' Aligns with destructiveHint=true and openWorldHint=true. No contradiction.

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?

Four sentences, each adding value: use case, preconditions, next steps, sensitivity. No redundant information. Well-structured and front-loaded.

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

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

Covers when, preconditions, and risks. Does not explicitly describe output format, but output schema exists. Complete enough for an agent to understand the tool's role and safety considerations.

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 0%, so description must compensate. It clarifies the need for acknowledgeRawCapture and acknowledgeDangerousEval, but does not detail other parameters like maxBytes, frameName, timeoutMs. Partial but inadequate 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?

Description explicitly states when to use: when safe DOM, action, wait, or trace tools are insufficient and exact JavaScript execution is essential. Clearly distinguishes from sibling tools by focusing on arbitrary 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?

Provides detailed guidance: preconditions (active page, acknowledgeRawCapture and acknowledgeDangerousEval), next steps (prefer targeted tool afterward, document necessity), and sensitivity warning. Excellent context for when and how to use.

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

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

The description adds sensitivity details about the exported file containing cookies, tokens, etc., which goes beyond the annotations. Annotations indicate readOnlyHint=false (so writing) and non-destructive, consistent with description. No contradictions.

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

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

Three sentences, each essential: purpose, preconditions/usage, sensitivity. Front-loads the main action. No redundancy or unnecessary 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?

Given the tool has an output schema and 5 parameters, the description adequately covers when to use, preconditions, and data sensitivity. It does not describe the output structure but that is covered by the output schema. Missing details like the file format (Playwright storageState) but assumed known.

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 mentions acknowledgeRawCapture and acknowledgeCredentialAccess in context but does not explain their role or any other parameter (maxBytes, indexedDB, outputPath). The description fails to compensate for the lack of 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 clearly states the tool exports a Playwright storageState file for reproduction/transfer, specifying the exact resource and purpose. It implicitly differentiates from sibling import_storage_state by focusing on export.

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

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

The description provides explicit when-to-use context ('full-profile authorized workflow needing storageState file'), preconditions (acknowledge flags, protected output path), and post-usage instructions. It lacks explicit when-not-to-use or comparison to related tools like browser_get_state.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. Description adds 'Sensitivity: filled values may be captured in the DOM, requests, screenshots, traces, or remote application state,' warning about data persistence beyond annotations.

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

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

Three sentences with clear flow: usage indication, preconditions, next steps, sensitivity. No unnecessary 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?

Covers purpose, preconditions, next steps, and sensitivity. Output schema exists, so return values are not needed. Could mention minItems constraint for fields array or default timeoutMs, but overall complete for a form-filling 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%. Description mentions 'unambiguous field selectors, names, labels, or placeholders' which hints at fields array properties but does not detail timeoutMs or submitSelector. Without schema descriptions, more parameter guidance would be beneficial.

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 'Use when multiple form controls must be populated consistently and optionally submitted during a reproduction.' It specifies verb 'fill' and resource 'form', and distinguishes from sibling tools like browser_type (single field).

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?

Preconditions are explicit: 'active page and unambiguous field selectors, names, labels, or placeholders are required; provide only intended test data.' It advises next steps. However, it does not explicitly mention when not to use or name alternatives, though siblings imply differentiation.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. Description adds that acknowledgeRawCapture must be true and results may contain sensitive content. No contradiction.

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: purpose, preconditions+next steps, sensitivity. Efficient but first sentence uses jargon ('full-profile diagnosis') which may be unclear. No wasteful content.

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 many sibling tools and output schema exists, description provides good overall context. But fails to explain all parameters (0% schema coverage), so agent may miss how to filter or limit results.

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

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

Schema has 0% coverage; description only mentions acknowledgeRawCapture, and incorrectly as required. No explanation for limit, selector, or textContains. Agent cannot infer their purpose from 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?

Description clearly states the tool retrieves DOM-derived accessibility info (roles, names, states, summaries). Differentiates from siblings like browser_get_dom and browser_get_elements by specifying accessibility focus.

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

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

Provides use condition ('when full-profile diagnosis needs accessibility') and preconditions (active page, acknowledgeRawCapture). But incorrectly states acknowledgeRawCapture as required (schema says optional), misleading the agent. Lacks when-not-to-use or 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?

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint. The description adds important behavioral context: that cookies are credentials and must be treated as secrets, and that specific acknowledgments are required. This adds value beyond annotations without contradiction.

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 concise with three sentences that are front-loaded: use case, preconditions, and post-use guidance. Every sentence adds essential information with no 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?

Given the presence of an output schema, the description does not need to explain return values. It covers the main use case, sensitivity, and preconditions. However, it misses explaining the 'urls' parameter, which is a minor gap. Overall, it is complete enough for an experienced 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 explain parameters. While it mentions the acknowledgment booleans in the preconditions, it provides no explanation for the 'urls' parameter (array of URIs). This leaves a significant gap in understanding how to use the tool effectively.

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

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

The description clearly states the tool's purpose: reading raw cookie values for authentication or diagnosis. It uses a specific verb ('read') and resource ('cookies'), and distinguishes from sibling tools by emphasizing 'raw cookie values' and the special preconditions.

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

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

The description explicitly states when to use (full-profile auth or cookie-specific diagnosis), required preconditions (acknowledgments), and post-use guidance (inspect only relevant fields, avoid copying). It effectively guides the agent on appropriate use cases and constraints.

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

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

The description adds a sensitivity warning about raw DOM containing secrets, personal data, etc., which goes beyond the annotations (readOnlyHint, idempotentHint, destructiveHint). It does not contradict 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 concise: three sentences covering purpose, preconditions/next steps, and sensitivity warning. Information is front-loaded and every sentence adds value.

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, an output schema, and annotations. The description covers purpose, usage guidelines, preconditions, and sensitivity, but lacks full parameter explanations. Output schema exists, so return values are documented. Overall fairly complete.

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

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

Schema coverage is 0%, so the description must compensate. It mentions acknowledgeRawCapture as required and selector as optional, but does not explain mode or maxBytes parameters. Partial guidance but insufficient for complete 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 clearly states the tool's purpose: to retrieve DOM HTML/text for a page region to understand transient state, hidden content, or selector behavior. It also distinguishes from sibling tool 'browser_get_elements' by specifying the different use case.

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

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

The description explicitly lists preconditions (active page, acknowledgeRawCapture: true), recommends narrowing with a selector, and suggests next steps (use browser_get_elements for actionable targets or compare DOM mutations). It covers when to use and when not, including 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?

Annotations already declare readOnlyHint and destructiveHint. The description adds useful context about sensitive information (paths, filenames, URLs). No contradiction with annotations. Could mention that it returns a list of download objects.

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 concise sentences conveying purpose, preconditions, next steps, and sensitivity. Front-loaded with key information. 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?

Given the tool's simplicity and presence of an output schema, the description covers preconditions, next actions, and sensitivity. It is complete for agent decision-making.

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% (limit parameter has no description). The description does not mention the 'limit' parameter or its semantics, despite the parameter being optional but meaningful. 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 the tool's purpose: to locate or verify saved downloads after a download flow. It specifies the resource (downloads) and context (current runtime), differentiating it from other browser tools which focus on navigation, DOM, etc.

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

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

Provides explicit when-to-use ('after a download flow'), preconditions ('at least one download should have completed'), and next steps ('use the relevant local file with an appropriate parser or test assertion'). This offers comprehensive 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?

Annotations already indicate readOnlyHint, idempotentHint, openWorldHint. The description adds context about sensitivity of returned metadata (visible text, attributes, values) and the need for acknowledgeRawCapture. No contradiction with annotations.

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

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

Four sentences with no redundancy. Purpose, preconditions, filtering, and next step are front-loaded. Every sentence adds value; efficient and structured.

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

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

Given 4 un-documented parameters and an existing output schema, the description covers purpose, filtering, preconditions, and next steps adequately. It could note that 'limit' caps results, but overall sufficient for an interactive element listing tool.

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

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

Schema coverage is 0%, so description carries burden. It explains 'acknowledgeRawCapture' and 'selector'/'textContains' for filtering but does not elaborate on 'limit'. Partial compensation for missing schema docs, but incomplete.

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

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

The description clearly states the tool's purpose: 'list interactive elements' and specifies the use case for obtaining stable selectors and metadata before actions. It distinguishes from sibling tools like browser_snapshot and browser_get_dom by focusing on interactive elements rather than state or raw DOM.

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 clear preconditions (active page, acknowledgeRawCapture), suggests filtering by selector/text on large pages, and recommends the next step (browser_observe_action_result). It does not explicitly state when not to use, but the guidance is adequate for correct invocation.

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

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

Annotations already mark the tool as read-only, idempotent, non-destructive. The description adds context about capturing raw form data and warns about sensitivity (hidden values, personal data). No contradictions.

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

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

Four concise sentences, each serving a distinct purpose: purpose, preconditions, next steps, sensitivity. No redundant information.

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

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

Despite having output schema, the description fails to cover parameter semantics for 5 parameters. Given low schema coverage (0%), this is a significant gap that reduces completeness for effective tool 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 coverage is 0%, yet the description only mentions acknowledgeRawCapture in preconditions. It does not explain the purpose of limit, maxBytes, selector, or textContains, leaving agents to guess filtering and other options.

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 retrieves form structure, labels, controls, values, validation state, and submit targets. It specifies the use case 'before reproducing a form issue', differentiating it from other browser inspection 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?

Provides explicit preconditions (active page, acknowledgeRawCapture: true), guidance to filter forms, and next steps referencing sibling tools (browser_fill_form, browser_observe_action_result). Also notes sensitivity.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable context about sensitivity: 'network summaries can expose URLs, headers, status details, and references to sensitive bodies.' This goes beyond annotations without contradiction.

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 with 4 sentences, each serving a clear purpose: when to use, preconditions, next steps, and sensitivity. It is front-loaded with the most critical information.

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

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

Given the 6 parameters, 0% schema coverage, and presence of output schema, the description covers usage, preconditions, next steps, and data sensitivity. It is fairly complete, though more detail on parameter meanings would elevate it further.

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 mentions filtering by URL, method, status, or sequence, which corresponds to urlContains, method, status, and sinceSeq parameters. However, it does not describe all 6 parameters (e.g., limit, sessionId) in detail, leaving some gaps.

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 explicitly states when to use this tool: to explain a click with no request, wrong endpoint, etc. It clearly identifies the tool's purpose to get recent network event summaries and distinguishes it from sibling tools like monitor_search_events and monitor_search_bodies.

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

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

The description provides explicit when-to-use guidance, preconditions (a trace session must exist), and next steps (use monitor_search_events or monitor_search_bodies). It also recommends filtering by URL, method, status, or sequence when possible.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds valuable context beyond that: preconditions for authorized environment, sensitivity about exposing URLs/frame metadata, and a next step. No contradiction.

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 efficient sentences: purpose, preconditions/next step, sensitivity. No redundancy, all sentences earn their place.

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

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

Covers all essential aspects: purpose, preconditions, usage context, alternative (browser_snapshot), sensitivity. Output schema exists so return values need not be detailed. Complete for this tool.

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

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

Schema coverage is 0% for the single parameter 'acknowledgeRawCapture'. The description mentions it is required in authorized environment but does not explain its meaning or behavior. Minimal value added.

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 specific verbs ('get') and resources ('page state'), listing exact elements (URL, title, frames, viewport, focused element). It distinguishes from sibling 'browser_snapshot' by noting that tool provides richer context.

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

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

Explicitly states when to use ('when the current URL, title, frames...is needed'), preconditions (active page, acknowledgeRawCapture required), and provides a clear next step ('use browser_snapshot...'). No ambiguity.

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

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

Annotations already declare readOnly, openWorld, idempotent, non-destructive. The description adds critical context: storage sensitivity (tokens, identifiers, personal data) and required acknowledgments. No contradiction.

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 focused sentences, front-loaded with usage condition, no redundant text. Every sentence adds value.

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?

Use case and behavioral context are well covered, and output schema exists. However, with zero parameter description coverage and 5 parameters, the description is incomplete for effective tool 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 coverage is 0%; the description does not mention any of the 5 parameters. Agents receive no guidance on origin, maxBytes, includeSessionStorage, or the acknowledgment booleans beyond schema field 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?

Description clearly states the tool reads localStorage or sessionStorage for authentication or application-state diagnosis, distinguishing it from sibling tools like browser_get_cookies or browser_get_state.

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

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

Provides explicit preconditions (acknowledgeRawCapture, acknowledgeCredentialAccess) and next-step guidance (inspect relevant keys, avoid raw secrets). Implicitly restricts usage to contexts requiring full-profile auth or state diagnosis. Could be strengthened by directly stating when not to use.

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

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

Beyond annotations (destructiveHint: true), description adds context: 'history navigation can reissue requests and expose credential-bearing page state.' This warns about side effects not obvious from annotations alone. Good addition.

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?

Extremely concise: three sentences plus two labeled points (preconditions, next, sensitivity). Every sentence adds distinct value. Purpose is immediately clear in the first 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?

Covers purpose, usage, and behavioral effects well, but completely omits parameter documentation. Output schema exists but not shown. Given the tool's simplicity and available annotations, the description is adequate but not fully self-contained due to missing param info.

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% (no parameter descriptions in schema). The description does not mention or explain timeoutMs or waitUntil. As the tool has two parameters, this is a critical gap; the agent has no guidance on using them effectively.

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 specific use case: 'reproduce a redirect, back-button state bug, or single-page application history issue.' It provides a specific verb-resource combination and distinguishes from forward navigation implicitly.

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?

Explicitly states when to use ('when history navigation is specifically needed'), preconditions ('active page with a previous history entry required'), and post-use guidance ('inspect state and relevant network events'). Could be improved by explicitly naming alternatives like browser_go_forward or browser_navigate.

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?

Adds context beyond annotations by noting that navigation can reissue requests and expose credential-bearing page state. Annotations already indicate destructiveHint=true; description reinforces sensitivity.

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 focused sentences with no repetition or fluff. Each sentence adds value: usage scenario, preconditions, and behavioral sensitivity.

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?

Covers key aspects for a navigation tool: purpose, preconditions, sensitivity. Output schema exists to handle return values, so explanation is sufficient. Minor omission: no mention of waiting for navigation to complete, but waitUntil parameter implies it.

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

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

Schema coverage is 0%, and the description does not explain the two parameters (timeoutMs, waitUntil). The agent must infer meaning from names and enums alone, making parameter usage less clear.

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?

Clearly states the tool is for forward history navigation, specifying exact use cases like reproducing cached states, redirects, or SPA history issues. Distinguishes from siblings by being the only forward navigation tool.

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

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

Provides preconditions (active page with forward history) and post-navigation suggestions. However, does not explicitly state when not to use or compare to alternatives like browser_go_back or browser_navigate.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, so the description adds moderate value by explaining sensitivity: 'permissions expose device-like capabilities and can change what the target page may access.' This provides context beyond the annotations, but does not detail side effects or revocation.

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

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

The description is three sentences long, each earning its place: purpose, preconditions, and sensitivity/next steps. It is front-loaded with the key verb and resource, with no redundant or vague language.

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 (permission grant with preconditions and sensitivity), the description covers when to use it, prerequisites, and behavioral implications. With an output schema present, return values are handled elsewhere, making this fairly complete. Minor gap: no mention of error cases or handling denied permissions.

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 provides examples for the 'permissions' parameter (geolocation, notifications, etc.) and implies that 'acknowledgePermissionChange' should be true via preconditions. However, the 'origin' parameter is not explained, leaving it unclear.

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

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

The description clearly states the tool's purpose: granting browser permissions like geolocation, notifications, camera, or microphone. It uses a specific verb ('grant') and resource ('browser permissions'), and distinguishes itself from sibling tools by focusing on permission management, not navigation or DOM interaction.

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

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

The description provides explicit usage guidance: 'Use when a full-profile authorized test explicitly requires browser permissions' and lists preconditions (acknowledgePermissionChange: true, minimal permission list). It also suggests next steps ('run the permission-dependent flow') and warns against granting unrelated capabilities. However, it does not mention alternatives because no other sibling tool performs this function.

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?

Adds context beyond annotations (destructiveHint=true) by noting that accepting prompts can submit text, authorize actions, or mutate state. No contradiction with annotations.

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

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

Three sentences with front-loaded purpose and clear structure. Slightly verbose but 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?

Adequate for a simple 3-param tool with output schema, but missing parameter explanations in description reduces completeness.

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

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

No parameter descriptions in schema (0% coverage) and description does not explain 'once', 'action', or 'promptText' meaning, leaving agents to infer from enum values and type alone.

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 specifies the tool handles JavaScript dialogs (alert, confirm, prompt, beforeunload) that block or change browser reproduction, clearly distinguishing it from navigation and interaction 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?

Provides preconditions (configure behavior before dialog appears) and next steps (trigger dialog and inspect result), but lacks explicit when-not-to-use or alternative tools.

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

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

The description adds context beyond annotations by warning that 'hover handlers can trigger network requests, analytics, or application state changes', which is consistent with readOnlyHint=false and destructiveHint=false.

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

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

Three sentences, front-loaded with the primary use case, and no redundant information; every sentence adds value.

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 and the presence of an output schema, the description covers preconditions, side effects, and next steps. However, the lack of parameter descriptions slightly reduces completeness.

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

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

With 0% schema description coverage, the description fails to explain the meaning or constraints of the two parameters (selector and timeoutMs), leaving the agent to rely solely on the JSON schema, which lacks 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 explicitly states the tool is for 'hover-driven menus, tooltips, lazy content, or transient UI state', using a specific verb and resource, distinguishing it from sibling tools like click or type.

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

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

Provides clear preconditions ('active page and precise selector required') and a recommended next step ('inspect the transient DOM or continue'), but does not explicitly list alternatives or when not to use.

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 action clears and replaces cookies, localStorage, and IndexedDB, and can overwrite a real logged-in profile. This goes beyond the annotations (destructiveHint=true) by detailing exactly what is destroyed.

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 concise sentences: first states purpose and when to use, second lists preconditions, third gives next step and sensitivity. No irrelevant information.

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

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

Given the tool's destructive nature and the presence of an output schema (so return values need not be explained), the description covers preconditions, behavioral effects, and next steps adequately.

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 compensates by explaining the purpose of the acknowledgment parameters (raw-capture, credential, overwrite). The 'path' parameter is implied but not explicitly described; still, it adds significant meaning beyond the schema.

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

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

Description clearly states the tool replaces active browser credentials and origin state from a Playwright storageState file, with a specific verb ('import') and resource ('storage state'). It distinguishes this from siblings like browser_export_storage_state.

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

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

Description provides explicit preconditions (acknowledgments required) and a next step (navigate/reload). It does not explicitly list alternatives or when not to use, but the specific context ('full-profile authorized reproduction') implies narrow 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?

Annotations indicate openWorldHint=true and destructiveHint=false. The description adds that launch options can expose existing browser profiles, CDP sessions, or credential-bearing storage states, supplementing the annotations with useful behavioral context.

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 multiple sentences but front-loaded with the core purpose. Every sentence adds value, though it could be slightly more concise without losing clarity.

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 launch tool with 7 parameters (none required) and an output schema, the description covers when, preconditions, next steps, and sensitivity. It adequately prepares the agent, though it does not detail the output structure (handled externally).

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

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

Schema description coverage is 0%, but the description mentions key parameters like profiles, storage state, and CDP endpoint. It also references the acknowledge booleans in preconditions. However, it does not explain each parameter in detail, limiting the added value for an agent.

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 launches a RawTrace-controlled Chromium session or opens a CDP endpoint/storage state. It distinguishes from siblings like browser_attach_cdp by specifying when a session is not running yet.

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

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

Provides explicit when-to-use context, preconditions (authorization, acknowledgements), and next-step suggestions (navigate/inspect, then use browser_observe_action_result or monitor_start). Also implies when-not-to-use by mentioning 'not running yet'.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. Description adds sensitivity warning about tab URLs and titles, which is valuable context beyond annotations.

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

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

Three sentences: purpose, preconditions+next step, sensitivity. Front-loaded and every sentence adds value.

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 tool with an output schema, description covers usage, preconditions, follow-up tool, and data sensitivity. No gaps.

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

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

Schema has 0 parameters with 100% coverage, so no param info needed. Baseline 4 applies; description correctly adds no redundant param details.

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

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

Description states 'discover the open pages before switching, closing, or selecting a CDP target' with specific verb 'list' and resource 'browser tabs'. It distinguishes from siblings by mentioning typical workflow sequence.

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?

Explicitly says 'Use when...' and provides preconditions ('active browser context required') and next steps ('use browser_switch_tab'). Does not list exclusions, but context is clear.

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

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

Beyond annotations (destructiveHint, readOnlyHint), the description adds that navigation contacts an external origin and may send cookies/credentials, and warns about authorized scope, enhancing 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?

Three sentences, front-loaded with purpose, no fluff. Each sentence adds distinct, valuable information (purpose, preconditions/next steps, sensitivity).

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 (2 params, output schema exists), the description covers use cases, preconditions, sensitive behavior, and follow-up actions, making it complete for agent decision-making.

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 fails to explain the parameters (url format, waitUntil enum values). It only mentions 'exact URL', leaving the agent without full parameter guidance.

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 navigates to an exact URL for specific use cases like reproduction, redirect investigation, etc., and distinguishes from sibling navigation tools (e.g., browser_go_back).

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

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

Explicitly states when to use (authentication flow, network-timing diagnosis), preconditions (browser active, destination in scope), and next steps (inspect state, use monitor_get_summary).

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

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

The description adds significant behavioral context beyond annotations: it notes the external origin contact and credential sensitivity, and mentions the need to close the tab after use. This aligns with openWorldHint true and readOnlyHint false 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 extremely concise, using four short sentences with clear sections (use case, preconditions, next steps, sensitivity). Every sentence adds value; 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?

The description covers the tool's role, preconditions, and sensitivity, but omits explanation of the 'waitUntil' parameter behavior. Since an output schema exists, return values need not be described. The gap on parameter semantics prevents a perfect score.

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 compensate. It adds context for the 'url' parameter (must be authorized), but provides no explanation for the 'waitUntil' enum. This partial coverage earns a middle score.

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

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

The description clearly states the tool's purpose: opening a new tab when a separate page is needed, distinguishing it from browser_navigate which uses the existing tab. The verb 'open' and resource 'new tab' are explicit.

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

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

The description provides explicit when-to-use guidance ('when a full-profile reproduction genuinely requires a separate page'), preconditions (active browser context, authorized URL), and next steps (inspect/trace then close). It also contrasts with the sibling tool browser_navigate by implication.

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

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

Annotations already mark destructiveHint=true, so the destructive nature is known. The description adds a sensitivity warning about sensitive raw page data in the diff. It does not contradict annotations, but beyond that, it does not disclose additional behavioral traits such as side effects on page state or rate limits.

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 four sentences with clear front-loading of purpose and usage. Every sentence adds value: when to use, preconditions, next steps, and sensitivity. No unnecessary information.

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

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

The description covers purpose, usage, and output context (diff with DOM, state, network, screenshot). However, given the high parameter count (7 with nested objects) and lack of parameter explanations, it is not fully complete. Output schema existence reduces the need to describe return values, but parameter semantics remain a gap.

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

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

Schema description coverage is 0% for the 7 parameters (many nested). The description does not explain any parameter individually, such as the 'action' variant details or the snapshot options. This leaves the agent to infer from the schema alone, which is insufficient given the complexity.

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 starts with 'Use when one click, type, press, check, select, hover, scroll, reload, navigate, or authorized eval has an unclear outcome and a compact before/after diff is needed.' This clearly states the tool's purpose (observing action results) and distinguishes it from siblings that perform actions or take snapshots without the diff context.

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

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

The description specifies when to use (unclear outcome, need compact diff), preconditions (active page, acknowledgeRawCapture, acknowledgeDangerousEval for eval), and next steps (use returned diff to decide if longer monitoring is needed). It does not explicitly list when not to use or name alternative tools, but the context is clear.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds a useful sensitivity warning: 'candidate analysis reads DOM attributes and text that may be sensitive.' This provides behavioral context beyond the annotations, earning a score above baseline.

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: three sentences covering purpose, preconditions, next step, and sensitivity. Every sentence adds value with no redundancy or filler.

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

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

While the description provides high-level context and a sensitivity warning, it omits details about the output (which is partially covered by an output schema) and the many parameters. For a tool with 8 parameters and no parameter descriptions, more guidance on how to construct a good request would improve completeness.

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

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

Schema description coverage is 0%, yet the description only mentions two parameters (selector and acknowledgeRawCapture) without explaining their semantics or usage. Six other parameters remain entirely undocumented. The description fails to compensate for the low schema coverage.

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

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

The description clearly states the tool's purpose: to optimize a selector to be shorter and unique for a known target. The verb 'optimize' and resource 'selector' are specific, and no sibling tool performs this function, so it is well-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 provides clear usage context: 'Use when a full-profile workflow needs a shorter unique selector.' It lists preconditions (active page, acknowledgeRawCapture true, valid selector) and a next step (verify with browser_get_elements). However, it does not explicitly state when not to use or mention alternatives, which would be helpful.

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

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

Beyond annotations (readOnly, idempotent, non-destructive), the description adds sensitivity about repeated raw capture of text, values, etc. No contradiction with annotations.

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

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

The description is three sentences, front-loaded with purpose, preconditions, next step, and sensitivity. No wasted words, each sentence adds value.

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 (6 parameters, nested objects, condition variants) and 0% schema coverage, the description lacks details on match modes, snapshot fields, and condition syntax. An output schema exists but is not shown; description needs to compensate more.

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 mentions timeout, interval, and acknowledgeRawCapture but does not explain match, snapshot sub-properties, or condition details. The high-level hints are insufficient for a complex input 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's purpose: polling until conditions match for asynchronous DOM, URL, element value, or auth signals. It uses specific verbs and resources, distinguishing it from sibling tools like browser_snapshot (single snapshot) or browser_wait (fixed 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 explicitly says when to use it ('use when asynchronous...'), lists preconditions (active page, acknowledgeRawCapture: true, bounded timeout/interval), and suggests next steps. It lacks explicit when-not-to-use but provides sufficient context.

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

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

The description adds crucial context beyond annotations by stating 'key presses can submit data, trigger shortcuts, navigate, or mutate remote state,' aligning with destructiveHint: true and readOnlyHint: false. It does not contradict any 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?

Three sentences, each serving a distinct purpose: when to use, preconditions and next steps, and sensitivity. No redundant or irrelevant information.

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

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

The description covers purpose, preconditions, side effects, and follow-up actions. An output schema exists (not shown), so return value explanation is not required. However, it lacks detail on all four parameters, particularly delayMs and timeoutMs, leaving some gaps 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 mentions 'key' implicitly via examples (Enter, Escape, Tab) and 'selector' as optional, but does not explain delayMs or timeoutMs, leaving their purpose ambiguous. More parameter detail is needed.

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

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

The description clearly states 'Use when a keyboard action such as Enter, Escape, Tab, or a shortcut is part of the browser reproduction,' specifying both the verb and resource. It distinguishes from siblings like browser_click (mouse clicks) and browser_type (text input).

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 provides explicit preconditions ('an active page is required and the optional selector must identify the intended focus target') and suggests subsequent actions ('continue the sequence or inspect any resulting navigation, dialog, DOM, or network activity'). While it doesn't explicitly list exclusions or alternatives, the context implies when to use this tool vs. browser_type for typing.

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

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

Beyond annotations (destructiveHint=true, readOnlyHint=false), the description adds critical context: reload can repeat writes/requests and may transmit active credentials. This explains the destructive nature and security implications, going well beyond what annotations provide.

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

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

Three sentences, each serving a clear purpose: usage scenarios, preconditions/next steps, and sensitivity. Front-loaded with the most critical information. No redundant or 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 usage context, preconditions, next steps, and behavior. However, it omits parameter semantics entirely, which is a significant completeness gap given the tool's moderate complexity and the presence of an output schema.

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

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

Schema description coverage is 0%, meaning the schema provides no parameter descriptions. The tool description does not mention or explain the two parameters (timeoutMs, waitUntil), leaving the agent without crucial semantic information 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 clearly states specific use cases for reload: reproducing initialization races, cached-versus-fresh behavior, redirects, or intermittent requests. This distinguishes it from sibling navigation tools like browser_navigate, browser_go_back, etc., which serve general 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?

The description gives explicit preconditions (active page required, start monitor_start first) and hints at next steps (inspect state or read trace summary). It lacks explicit directions on when NOT to use the tool, but the listed scenarios provide clear context for appropriate use.

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

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

Annotations provide minimal behavioral info (readOnlyHint=false, openWorldHint=true). The description adds critical context: screenshots may capture sensitive data and are written locally. It also hints at region selection behavior. This is good but could mention if it waits for network idle or page load.

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-loading the use case and preconditions. Every sentence adds value. However, it could be structured into bullet points for clarity, but conciseness is not sacrificed.

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 moderate complexity (4 parameters, no required ones, output schema exists), the description covers usage and sensitivity but misses parameter details. The output schema relieves some burden for return values, but the parameter ambiguity lowers completeness.

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

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

Schema description coverage is 0%, so the description must explain parameters. It mentions acknowledgeRawCapture as a precondition and region selection, but does not define parameters like 'selector' (CSS selector? Coordinates?), 'outputPath' (path format?), or 'fullPage' (true/false behavior). This lack of detail impedes 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 clearly states the purpose: capturing visual evidence for layout, overlays, rendering, or interaction results. It distinguishes from siblings like browser_snapshot and browser_screenshot_annotated by emphasizing visual evidence for layout analysis.

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

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

The description provides explicit preconditions (active page, acknowledgeRawCapture: true), guidance on when to select a region vs full page, and suggests next steps (targeted DOM or trace inspection). It also notes sensitivity, giving an exclusionary condition for alternative tools.

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

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

Annotations show `readOnlyHint=false`, consistent with writing locally. The description adds sensitivity warnings and local writing behavior, beyond annotations. No contradictions.

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

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

The description is moderately concise but uses verbose phrases like 'full-profile visual diagnosis'. It front-loads the use case but could be tighter.

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 output schema existing, the description lacks parameter details, leaving the agent uncertain how to construct valid inputs. Preconditions are stated but 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?

With 0% schema coverage, the description does not explain the purpose or usage of most parameters (e.g., `boxes`, `selector`, `fullPage`). It only mentions `acknowledgeRawCapture` as required, contradicting the optional 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 captures annotated screenshots for visual diagnosis, distinguishing it from the unannotated sibling `browser_screenshot`. The verb 'capture' and resource 'annotated screenshot' are specific.

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

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

The description provides explicit preconditions (active page, `acknowledgeRawCapture: true`) and next steps. It implies the use case (full-profile visual diagnosis) but does not explicitly state when to avoid this tool in favor of alternatives.

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

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

The description goes beyond annotations by stating scroll listeners can trigger external requests, analytics, and dynamic content loading. This adds valuable context about side effects, which is not covered by the annotations (readOnlyHint=false, destructiveHint=false).

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

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

The description is three concise sentences, each earning its place: purpose and use cases, preconditions and next steps, and sensitivity. Front-loaded with key information, 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 purpose, use cases, and behavioral traits adequately but lacks parameter details. Given the tool has 4 parameters and no schema descriptions, the description is incomplete for proper parameter 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?

With 0% schema description coverage, the description should explain parameters but only mentions selector in passing. It does not define deltaX, deltaY, or timeoutMs, leaving meaning ambiguous. Some compensation for selector, but insufficient overall.

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 scrolls a page or element, and lists specific use cases like lazy loading, infinite scroll, sticky layout, viewport-dependent behavior, and off-screen targets. It distinguishes from sibling tools like clicks and hovers.

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 when to use (e.g., lazy loading, infinite scroll) and provides preconditions (active page required, selector only for specific regions) and next steps (wait for activity or inspect changes). However, it does not explicitly mention when not to use or directly contrast with alternative tools.

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

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

Annotations indicate destructiveHint=true, and the description reinforces this by warning that selection can submit forms or alter state. It goes beyond annotations by mentioning potential side effects (form submission, exposing values in traces) and suggesting next steps (inspect DOM/network). No contradiction with annotations.

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

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

The description is concise (three sentences) and front-loaded with purpose and preconditions. The sensitivity note is useful but slightly dense. Could be improved by breaking preconditions into a list for readability.

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 0% schema coverage, the description should provide more detail about parameters and expected outputs. While it notes next steps, it omits return format, error cases, and detailed parameter behavior. For a tool with 3 parameters and potential side effects, this is insufficient.

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 should compensate, but it only hints at parameters ('intended value, label, or index') without explaining the complex schema for the 'values' parameter or describing 'selector' and 'timeoutMs'. The agent lacks guidance on how to structure input for multi-select or specifying options by index/label/value.

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

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

The description clearly states the tool's purpose: selecting one or more values in a native select control. It uses a specific verb ('select') and resource ('native select control'), and distinguishes itself from sibling tools like browser_click or browser_type.

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

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

The description mentions preconditions (active page, precise selector, value/label/index), which implies when it should be used. However, it does not explicitly contrast with alternatives or state when not to use this tool. The 'Sensitivity' warning adds context but does not guide choice between tools.

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

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

Annotations indicate readOnly false, destructive true, and open world. The description adds context about credential handling and secrecy, enhancing transparency without contradicting 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 concise with no unnecessary words, front-loaded with purpose. It could be slightly more structured but is effective.

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 moderate complexity and an output schema, the description covers preconditions and sensitivity but lacks details on behavior like overriding cookies or return values, leaving 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%, but the description does not detail the cookies array or its properties. It mentions the acknowledge flags as preconditions, which adds some meaning, but fails to fully compensate for the lack of 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 clearly states the tool establishes or changes cookie state, aligning with its name and title. However, it does not explicitly distinguish from sibling tools like browser_import_storage_state that may also set cookies.

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

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

The description explicitly says when to use this tool ('full-profile authorized test requiring establishing or changing cookie state') and lists required preconditions. It does not mention alternatives, though the context is clear.

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

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

The description adds significant behavioral context beyond annotations: it warns that coordinates are exposed to authorized pages (sensitivity), specifies that only intended coordinates should be supplied, and outlines preconditions and next steps. This complements the destructiveHint and openWorldHint annotations without contradiction.

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: four sentences, each serving a distinct purpose (purpose, precondition, next step, sensitivity). It is front-loaded with the primary purpose and requires no editing.

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

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

Given the tool's complexity (4 parameters, output schema exists), the description covers the essential aspects: when to use, preconditions, post-conditions, and a security warning. It does not explain error handling or alternative approaches, but the provided information is sufficient for correct invocation.

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

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

With 0% schema description coverage, the description compensates by explaining the role of latitude, longitude, and accuracy as 'controlled' values, and specifically notes that acknowledgeLocationAccess must be true. It does not detail each parameter's format (schema handles that), but adds meaning by connecting parameters to the use case and precondition.

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

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

The description clearly states the tool's purpose: setting browser geolocation for authorized tests. It uses specific verbs ('set'), resource ('geolocation'), and context ('full-profile authorized test'), distinguishing it from sibling tools that handle navigation, permissions, or other browser actions.

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

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

The description explicitly states when to use the tool (when a test depends on controlled geolocation) and provides preconditions (acknowledgeLocationAccess: true) and next steps (reload or exercise behavior). It does not explicitly mention when not to use or alternative tools, but the guidance is clear and actionable.

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

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

Annotations indicate destructiveHint=true and readOnlyHint=false. The description confirms this by stating 'this changes potentially credential-bearing application state' and requiring acknowledge flags. No contradiction, and it adds context about credential sensitivity beyond annotations.

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

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

The description is four sentences, somewhat concise, but the first sentence is long and could be broken for readability. It avoids waste but lacks structured presentation of preconditions and steps.

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 destructive behavior and output schema present (not shown), the description covers preconditions and sensitivity but fails to detail parameter usage. It is complete for high-level context but lacks parameter guidance given 0% schema coverage.

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

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

Schema coverage is 0%, so description must compensate. It only mentions acknowledgeRawCapture and acknowledgeCredentialAccess as prerequisites, but does not explain origin, localStorage, or sessionStorage parameter semantics. This is insufficient for correct usage.

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 title 'Set Web Storage' and description explicitly state the tool sets localStorage/sessionStorage values. It clearly distinguishes from siblings like browser_set_cookies and browser_get_storage by specifying controlled web storage manipulation.

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 specifies when to use: 'full-profile authorized test explicitly needs controlled localStorage or sessionStorage values'. It provides preconditions (acknowledge flags) and next steps (reload/navigate). While it doesn't explicitly exclude other scenarios, the context is clear.

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

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

Beyond annotations, description warns of side effects like reflow, lazy loading, analytics, and network requests. This adds valuable transparency not captured by 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?

Three sentences cover use case, preconditions, and side effects efficiently. Could be more direct but no wasted content.

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 presence of output schema and annotations, description provides sufficient context for its two-parameter tool: when to use, preconditions, and behavioral impact.

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, description only says 'positive width and height', not explaining units or semantics (e.g., pixels). Minimal added value beyond the schema's constraints.

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

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

The description states the tool is for setting viewport dimensions when responsive breakpoints matter, which is clear and distinguishes from navigation or screenshot tools. However, it could be more direct like 'Sets browser viewport width and height.'

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

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

Provides context for when to use ('full-profile reproduction depending on responsive breakpoints') and preconditions, but lacks explicit when-not-to-use or alternatives among sibling tools.

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

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

The description adds behavioral context beyond annotations, such as mentioning that snapshots include DOM text, input values, links, and raw artifacts. This informs the agent of data sensitivity and scope.

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 (4 sentences), front-loaded with purpose, and contains no fluff. Every sentence adds value.

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 description fails to cover parameter semantics, which is critical for a tool with 6 undocumented parameters. The description is incomplete for effective tool 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 coverage is 0%, and the description does not explain any of the 6 parameters (selector, includeLinks, maxTextBytes, etc.). The description only broadly mentions what is captured, leaving agents without detailed guidance on parameter usage.

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

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

The description clearly states the tool's purpose: providing a compact combined view of page state, text, inputs, links, and interactive elements. It distinguishes itself from separate inspection calls, which are sibling tools.

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

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

The description gives specific preconditions (active page, acknowledgeRawCapture: true) and suggests next steps (select target for observe_action_result or compare with later snapshot). It does not explicitly state when not to use, but the context is clear enough.

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

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

Annotations indicate mutability (readOnlyHint=false) but no destructive effects. The description adds value by warning about private/authenticated sessions, which annotations do not cover. However, it does not explicitly state that the tool changes the active tab and preserves previous tab state, which would further improve 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?

Three concise, front-loaded sentences. First sentence states purpose, second gives preconditions/next steps, third handles sensitivity. No wasted words; every sentence earns its place.

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

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

Given the tool's simplicity (one parameter, no nested objects), the description covers purpose, preconditions, post-actions, and sensitivity. Output schema exists (not shown) but description does not need to explain it. Complete for an AI agent to correctly invoke.

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 that pageId must be obtained from browser_list_tabs or browser_attach_cdp, providing essential context. While it does not detail format, the source guidance sufficiently compensates for the lack of 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 clearly states the verb ('make a previously discovered page the active target'), specifies the resource (browser tab), and distinguishes from siblings like browser_new_tab and browser_close_tab by requiring a pre-obtained page ID and recommending a follow-up confirmation with browser_get_state.

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

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

Explicitly says 'Use when a full-profile workflow must make a previously discovered page the active target', provides preconditions (obtain page ID from specific tools), and advises confirming selection afterward. Also includes a sensitivity warning about private/authenticated content, giving clear when-to-use and precautions.

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

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

Annotations indicate destructive and non-read-only behavior. The description adds value by noting that typed values may be captured in DOM, console, network, screenshots, or trace artifacts, which is beyond what annotations provide. It does not contradict 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 three sentences with good front-loading of purpose. It is concise but could be slightly tighter, e.g., combining the sensitivity note with behavioral transparency. Overall, no unnecessary 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?

Given 0% schema coverage and moderate complexity, the description provides preconditions, next steps, and side effects. However, it omits details like whether the input is cleared before typing or parameter constraints (e.g., delayMs range is useful but not explained). Output schema exists but is not referenced.

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 mentions the requirement for a 'precise selector' and using 'data intended for the authorized target,' but does not explain delayMs or timeoutMs. The meaning of parameters is mostly inferred from names, with little added value.

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 types text into an input element during a reproduction. It includes preconditions like 'active page and precise selector' which help clarify the resource. However, it does not explicitly distinguish from siblings like browser_press or browser_fill_form, which might also involve text input.

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 indicates when to use the tool ('when text must be entered... during a reproduction') and mentions preconditions. However, it lacks explicit guidance on when not to use it or alternatives, such as using browser_press for keystrokes or browser_fill_form for form filling.

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

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

The annotations already indicate destructiveHint=true, meaning the tool can modify state. The description adds critical behavioral context by warning that it 'sends local file contents to the target site and can expose private data.' This goes beyond the annotations by highlighting security implications. No contradiction with annotations.

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

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

The description is three sentences long, with the most critical information (usage condition) in the first sentence. It efficiently communicates preconditions, next steps, and a security warning without redundancy. Every sentence adds value.

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 destructive nature and 4 parameters, the description covers purpose, preconditions, next steps, and sensitivity. It omits details about the return value (though an output schema exists) and the timeout parameter. Still, it provides sufficient context for an agent to use the tool correctly in most 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?

The input schema has 0% description coverage, so the description must compensate. It mentions the key parameters: 'acknowledgeFileAccess: true, an exact selector, and intended local paths' – which covers the required ones and the boolean flag. However, it does not explain the 'timeoutMs' parameter or provide details on the selector format. This is adequate but not exhaustive.

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

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

The description clearly states the tool's purpose: uploading local files to a page file input. It uses a specific verb ('upload') and resource ('local files'), and it distinguishes itself from sibling browser tools (e.g., browser_type, browser_click) by being the only one dedicated to file uploads. The context 'full-profile authorized test' adds precision.

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

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

The description explicitly states when to use the tool ('when a full-profile authorized test explicitly requires providing local files to a page file input') and provides preconditions (acknowledgeFileAccess: true, exact selector, intended local paths). It also suggests next steps ('continue the upload flow and verify'). However, it does not explicitly exclude cases where other tools might be better suited, but given its unique function, this is sufficient.

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

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

Annotations already declare readOnly, idempotent, and non-destructive. Description adds that waiting observes live page/network but does not redact captured data, providing extra behavioral context beyond annotations.

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

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

Extremely concise: two sentences plus preconditions and next steps. Every sentence adds value, no filler. Information is front-loaded and well-organized.

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 complexity (6 params, 1 enum) and existing annotations + output schema, description covers when, preconditions, next steps, and behavioral note. Lacks only some edge-case or error details, but overall sufficient.

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%. Description only mentions modes (selector, URL, quiet-period, timeout) and hints at narrow inputs. Does not explain parameters like delayMs, pattern, quietMs, timeoutMs, or their significance.

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 tool is for waiting for explicit browser conditions (selector, URL, quiet-period, timeout) instead of arbitrary sleep. Verb+resource is specific and distinguishes from other browser 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?

Provides clear preconditions (active page required, narrow inputs) and next steps (perform action after condition). Implicitly contrasts with arbitrary sleep, but does not explicitly list alternative tools or conditions to avoid.

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