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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states the high-level operations and does not mention side effects, network requests (e.g., when data is a URL), output format, error conditions, or reversibility. For a tool that can generate code and fetch remote responses, this is a significant transparency gap.

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

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

The description is a single sentence with no filler words. Each clause corresponds to a distinct action and adds concrete information. It is front-loaded with the primary capability and remains easy to scan.

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 four parameters, two required, no output schema, and no annotations, the one-line description is insufficient. It does not explain that data2 is only for diff, that data must be a URL for sdk, what the generated output looks like, or what side effects may occur. An agent would need to infer too much to use the tool reliably across all three actions.

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 covers data and data2 with descriptions, but action and lang lack descriptions. The description partially compensates by explaining the three actions and the Python/TypeScript language options, mapping to action and lang. However, it does not clarify parameter relationships such as data2 being needed for diff or that action defaults to schema. The addition of meaning over the schema is moderate, not outstanding.

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 specific verbs and resources for each mode: generate schemas, diff objects, create SDK boilerplate. It clearly communicates the three distinct capabilities of the tool and leaves no ambiguity about what it does. It is not a tautology and stands apart from the unrelated 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 lists what the tool can do but gives no guidance on when to use it, when not to use it, or which mode to choose in which situation. There are no explicit alternatives or exclusions. The agent must infer usage entirely from the action enum values.

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

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

With no annotations provided, the description must carry behavioral transparency on its own. It does state the core behavior—closing the session and releasing resources—which is meaningful. However, it does not disclose potential side effects such as losing page state, pending actions becoming invalid, or the implications of force-killing beyond what the schema parameter description already says.

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

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

The description is a single, grammatically complete sentence that communicates the essential action and consequence without filler. It is appropriately sized for a simple one-parameter tool and front-loads the primary action clearly.

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

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

For a simple, zero-required-parameter tool with no output schema, the description is mostly adequate, but it lacks usage context and side-effect warnings. The tool is destructive in nature, and an agent would benefit from knowing that closing the session is irreversible and that force is only needed when normal close fails. Overall completeness is acceptable but has clear gaps.

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

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

Schema description coverage is 100%, so the 'force' parameter is already documented as 'Force-kill the browser process.' The description adds no extra meaning about when force should be true or what the default behavior implies. This meets the baseline for a fully schema-documented parameter but does not exceed it.

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

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

The description uses a specific verb ('Close') and identifies the resource ('browser session'), making the tool's function unmistakable. It also clearly differentiates from siblings like browser_init and navigate by stating this terminates the entire session. No ambiguity remains about what operation this tool performs.

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

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

The description provides no guidance on when to call this tool versus alternatives, such as using it only at the end of a browser session or not for closing individual tabs. Nothing distinguishes appropriate usage scenarios or warns against misuse. The only implied context is the tool's name and sibling relationships, which is not explicit 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?

With no annotations, the description carries the full burden and does add some behavioral context: it mentions automatic recovery of stale sessions and exposes anti-detection/WebRTC protections. But it does not disclose consequences such as browser process lifetime, resource consumption, or the need to later call browser_close.

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

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

Two sentences with no filler: the first states the core action and enumerates capabilities, the second adds an important recovery behavior. The most important verb ('Initialize') is front-loaded.

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

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

For a 9-parameter tool with no output schema and no annotations, the description is too thin: it never states what the tool returns or how the agent knows initialization succeeded. It also omits setup details like proxy formatting or how contextOptions interact with defaults, leaving the agent to infer success criteria.

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 documentation already covers 7 of 9 parameters, and the description adds useful semantic grouping (e.g., 'biometric anti-detection hardware spoofing (WebGL, Canvas, AudioContext)' for spoofFingerprint, 'resource filtering' for enableBlocker, 'WebRTC leak protection' for blockWebRTCLeaks). This goes beyond the bare schema labels without being redundant.

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

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

The description opens with the specific verb 'Initialize' and a clear resource ('a browser session'), and the enumerated configuration options make its scope explicit. Among sibling tools like navigate, browser_close, and wait, this is unambiguously the session-start tool.

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

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

The description implies it should be used to start a browser session but never states when to call it, such as before navigation actions, or when not to use it. It also does not mention alternatives or warn against re-initializing an existing session, beyond the vague recovery behavior.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does reveal several behaviors: drag simulation with biological friction, iframe targeting, hover-before-click, video player API control, and automatic retry with fallback selectors. However, it omits side effects like auto-dismissing dialogs, force-click via JavaScript, and potential navigation outcomes from clicking.

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

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

The description is a single dense sentence that front-loads the core action and then lists supported capabilities. It is efficient with no filler, though the feature list is somewhat packed and could benefit from slight structural separation.

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

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

For a tool with 21 parameters, nested objects, and no output schema, the description gives a useful high-level summary but relies heavily on the schema for invocation details. It does not address return behavior or clarify which combinations of options are mutually exclusive or complementary, leaving moderate gaps for an agent selecting parameters.

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 90%, so the input schema already documents most parameter meanings. The description only names feature areas like dragTo and iframe handling without adding semantic detail beyond the schema, matching the baseline for high 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 opens with a specific verb and resource: 'Click or drag a page element by CSS selector or annotation ID.' It clearly states what the tool does and how elements are targeted, and the click/drag scope distinguishes it from sibling input tools like type and press_key.

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

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

The description gives no explicit guidance on when to prefer this tool over alternatives such as type, press_key, or see_page. Usage context is only implied by the tool name and the action verb, with no exclusions or routing recommendations.

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

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

With no annotations, the description carries the behavioral burden and does identify the tool as an inspection ('Inspect') that covers many read-oriented aspects of a page. However, it does not disclose whether the operation is truly read-only, whether it triggers network requests, how long it may take, or how results are returned. The listed coverage areas provide useful transparency, but side effects and output behavior remain unclear.

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

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

The description is a single dense sentence that front-loads the main purpose ('Inspect the current page in depth') before listing coverage areas. It is compact and free of filler, though the long enumerate list is slightly run-on and could be structured with separators or short phrases for easier scanning.

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 broad analysis tool with no output schema and no annotations, the description lists what is inspected but not what the agent should expect in return, whether results are aggregated, or how the optional boolean parameters alter the output. It is adequate for a first-order understanding but leaves operational detail unexplained.

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

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

Schema description coverage is only 67%, and the tool description adds no parameter-level meaning. The 'detailed' boolean is left undocumented, and the 'detectAccessControls' schema description ('Identify embedded widgets and page components') appears mismatched with the parameter name. The tool description echoes 'content-loading strategy recommendations' which maps to aiInsights, but that is redundant with the schema rather than additive.

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

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

The description uses a specific verb ('Inspect') and a concrete resource ('the current page'), and then enumerates a distinctive set of inspection areas (DOM, scripts, stylesheets, accessibility, performance, SEO, response headers, technologies, loading strategies). This makes it clearly distinguishable from sibling tools like see_page or get_content, which are narrower content/visual viewers.

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

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

The description implies the tool is for comprehensive, multi-faceted page analysis, but it does not explicitly state when to use it over siblings such as see_page, get_content, extract_data, or api_analyzer. There are no when-not-to-use conditions or alternative routing hints, leaving the agent to infer the intended use case.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It does mention several key traits: async execution, return value capture, and iframe targeting. However, it is silent on side effects of arbitrary JS execution, error handling, page-state impact, or limitations, which is a notable gap for a high-privilege execution tool.

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

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

The description is a single, efficient sentence with no filler. It front-loads the core purpose and then lists the key capabilities compactly, making it easy for an agent to parse quickly.

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 complex, potentially side-effect-heavy tool with 7 parameters and no annotations or output schema, the description is too sparse. It does not explain how return values are serialized, how iframe selection behaves in edge cases, what happens on timeout or JS errors, or what side effects may occur in the page.

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 high (86%), so the schema already documents most parameters. The description adds context around code, async, return value, and iframe targeting, but it does not clarify timeout, waitForIframe behavior, or the relationship between iframe and iframeSelector beyond what the schema provides.

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

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

The description clearly states a specific action ('Execute'), a resource ('custom JavaScript in the page context'), and includes differentiators: async support, return value capture, and iframe targeting. This makes it immediately distinct from sibling tools like click, type, or navigate.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives, nor does it mention exclusions or conditions where built-in browser actions should be preferred. Usage is only implicitly inferable from the phrase 'custom JavaScript'.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add useful scope information: extraction is from the current page, and links mode includes nested iframes. However, it does not disclose return behavior, auto-mode behavior, potential side effects, or whether any network/API calls are triggered by modes like apiDiscovery.

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

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

The description is a single, dense sentence with the core action front-loaded and the mode list following. It is efficient and contains no filler, though the long comma-separated list is somewhat heavy and could benefit from clearer grouping or line breaks.

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?

This is a complex 14-parameter tool with no output schema and no annotations, so the description must compensate. It provides a useful mode inventory but does not explain mode-to-parameter mapping, default behavior, return values, or failure modes. An agent would likely need to inspect the schema carefully and still be uncertain about how modes like apiDiscovery or transform behave end-to-end.

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 high at 86%, so the baseline is 3. The description adds value beyond the schema by defining ambiguous mode names: parse is 'string conversion,' transform is 'data format conversion,' and links mode explicitly covers nested iframes. This helps an agent understand the enumeration beyond raw parameter metadata.

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

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

The description states a clear verb and resource: 'Extract structured data from the current page,' and enumerates distinct extraction modes (regex, json, meta, structured, etc.). It does not explicitly differentiate from sibling tools like get_content or deep_analysis, but the mode list gives enough specificity that the purpose is not ambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives like get_content, api_analyzer, or media_extractor. It does not mention prerequisites, recommended modes for common scenarios, or exclusions. The only implicit usage signal is that it operates on the current page.

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

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

With no annotations, the description must carry the behavioral disclosure burden. It does add meaningful context: content can be returned in multiple formats, text/attributes/bounding boxes can be extracted, and results can be saved to a file. However, it does not disclose what is returned when saveAs is used, the effect of waitForJS, or whether rawHttp bypasses the browser rendering, leaving some behavioral gaps.

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

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

The description is only two sentences, front-loads the core purpose and format options, and avoids filler. Every sentence adds useful information about what the tool does or supports.

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 11 parameters, no annotations, and no output schema, the description is adequate but not complete. It explains the core operation and parameter-backed capabilities, but it does not describe the return contract, especially the behavior when saveAs is used, nor does it clarify how this tool relates to extract_data and see_page.

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 high at 82%, so the baseline for this dimension is 3. The description adds a little extra meaning by mentioning bounding box coordinates and file saving, which map to format=elements and saveAs, but it does not meaningfully clarify undocumented params like timeout or format beyond what the schema already provides.

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

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

The description clearly states the verb 'Get' and the resource 'page content', then names the available formats (html, text, markdown, rawHttp, elements) and types of extraction (text, attributes, bounding box coordinates). It does not explicitly differentiate this from sibling tools like extract_data or see_page, so it falls just short of a 5.

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

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

No guidance is given about when to prefer get_content over nearby sibling tools such as extract_data, see_page, or navigate. The description implies format-based use cases, but there are no exclusions, prerequisites, or explicit alternative-selection cues.

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

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

With no annotations provided, the description must carry the behavioral disclosure burden. It does disclose some behavior: extraction includes nested iframes, player_control operates 'via player API', and decode_url 'inspect[s] converted string and token formats.' However, it does not explain important behavioral aspects such as return values, side effects of switching iframes, what batch_extract returns, or how aiOptimize changes behavior. It is minimally adequate but not rich.

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

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

The description is a single dense sentence that front-loads the core purpose and then compactly lists the six actions with brief parenthetical explanations. There is no filler or redundancy. It is concise and easy to scan, though a bulleted structure could have improved readability given the multi-action nature.

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?

This is a 14-parameter, 6-action tool with no output schema and no annotations, so the description carries a heavy completeness burden. It outlines the actions but omits critical invocation context: which parameters are required for each action, what the output shape is, how iframe switching is resolved, and how decode_url parameters should be supplied. The description is a useful summary but not complete enough for an agent to confidently invoke many of the actions.

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 71%, so the description is expected to add meaning for the remaining gaps and for cross-parameter relationships. It names actions like batch_extract, decode_url, and player_control but does not clarify which parameters apply to which actions, how decoderKey/decoderIV/encodedData interact, or how index/selector relate to iframe actions. The action names mostly repeat the schema enum, adding little parameter-level 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 starts with a specific verb-resource pairing: 'Extract and control media from the current page.' It then enumerates six concrete actions, which clearly differentiates this tool from the sibling set (e.g., get_content, network_recorder, extract_data). The purpose is immediately understandable and not a mere restatement of the tool name.

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

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

The description lists supported actions but provides no guidance on when to use this tool instead of sibling alternatives like network_recorder, extract_data, or execute_js. There are no explicit conditions, exclusions, or routing hints. Usage context is only implied by the phrase 'from the current page' and the action list.

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

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

With no annotations, the description carries the behavioral transparency burden. It does disclose wait conditions, timeout, and automatic retry, which is useful. However, it does not mention side effects like tab state changes, auto-switching behavior, or what constitutes failure for a navigation attempt.

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

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

Two sentences, front-loaded with the primary purpose, and no filler. Every clause adds useful information about scope or configurable behaviors.

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 plus the detailed schema covers the core behavior for an 8-parameter tool, but with no annotations and no output schema, it leaves gaps around return values, failure semantics, and how this tool fits with sibling navigation-related tools. It is adequate but not fully complete.

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

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

Schema description coverage is high at 75%, so the baseline is 3. The description adds general context about configurable wait and retry, but it does not clarify uncovered parameters such as timeout units or the exact semantics of tabIndex for switching versus closing. The schema already provides most parameter meaning.

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

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

The description clearly identifies a specific verb and resource: 'Navigate to a URL' plus explicit tab management operations. It distinguishes this tool from siblings like click, type, and wait by scoping it to navigation and tab 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 implies when to use this tool (when you need to navigate or manage tabs) but provides no explicit guidance on when not to use it or how it relates to siblings like wait, see_page, or browser_init. The usage context is clear only by inference.

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

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

With zero annotations, the description carries the full disclosure burden, but it only adds two behavioral hints: the 3x-5x speed-boost claim for block_urls and the intercept/mock behavior of mock_route. It says nothing about side effects of start/stop/clear/clear_routes, whether recorded data persists, whether blocking or mocking survives navigation, or what the get actions return.

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

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

The main purpose is front-loaded in the first clause, and the action enumeration is dense but information-bearing — the parentheticals on block_urls and mock_route earn their place. It is a long single sentence, which slightly hurts scannability, but there is no wasted wording.

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?

This is a high-complexity tool: 14 actions, 6 parameters including nested objects, no output schema, and no annotations. The description answers 'what actions exist' but not 'when to use them', 'what happens when invoked', or 'what the recorded data looks like'. For an umbrella tool of this size, the description is a catalog, not a usable guide.

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 67% (4 of 6 params documented), with the nested filter object and the action enum lacking schema descriptions. The description partly compensates by spelling out all 14 action values with parenthetical meaning for the two least obvious ones (block_urls and mock_route). However, filter's subfields (type, mediaOnly, urlPattern, resourceType) remain unexplained in both schema and description.

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

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

The description opens with a clear verb+resource statement ('Record, inspect, and control network activity') and then enumerates 14 concrete actions, giving an agent a precise map of the tool's scope. It differentiates from browser-interaction siblings like click/type/navigate through the network focus, though it does blur slightly against api_analyzer and media_extractor given the overlapping get_api_calls/get_media 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?

No guidance is given on when to pick this tool over network-adjacent siblings. The description never names api_analyzer, media_extractor, or redirect_tracer as alternatives, nor does it explain which of the 14 actions fits which scenario. An agent must infer usage entirely from action names.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It mostly paraphrases the schema parameters and does not explain focus requirements, potential global or browser-level effects, or any side effects of pressing keys. This is minimal disclosure for a tool that simulates input.

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

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

The description is a single, concise sentence that front-loads the action and resource. Every phrase earns its place, with no redundant or vague filler.

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

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

For a relatively simple tool with fully documented parameters, the description is minimally adequate. However, it omits important context such as when to use this tool versus type, and whether the key press targets the page or the browser UI, which an agent would need to call it correctly in the right situation.

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

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

Schema description coverage is 100%, so the parameters are already well documented. The description adds no new semantic detail beyond summarizing modifier keys, repeat count, and keystroke delay, which is already visible in the schema.

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

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

The description states a specific verb ('Press') and resource ('keyboard keys'), and lists configurable aspects such as modifiers, repeat count, and delay. It is clear enough to be distinguished from sibling tools like click, though it does not explicitly differentiate itself from 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 implies when to use the tool — any time keyboard keys need to be pressed with modifiers or repetition — but it does not explicitly state when to prefer it over alternatives like type or click. No exclusions or comparison to sibling tools are provided.

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

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

With no annotations, the description must disclose side effects, but it says only that progress is tracked and time is estimated. It fails to mention that start/update/complete/clear mutate internal state, that updates are incremental, or how estimates are calculated beyond the schema hint on aiEstimate.

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 one-sentence description is tight and front-loaded, with no filler. It is appropriately concise but so short that it sacrifices informative content, though that tradeoff is accounted for in other dimensions.

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

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

For a multi-action stateful tool with no annotations and no output schema, the description is incomplete. It doesn't explain the action lifecycle, how taskName scopes state, what 'get' returns, or what 'clear' resets. An agent would need to inspect the schema and infer usage from enum names.

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

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

Schema coverage is only 50%, and the description compensates poorly: it adds context for progress and aiEstimate but says nothing about the required action enum semantics or what taskName identifies. The action parameter with five enum values is left entirely unexplained, which is a significant gap for a stateful tool.

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

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

The description states a clear verb ('track') and resource ('multi-step task progress') and adds the differentiator of estimated time remaining. It separates the tool from its browser-automation siblings, though it does not mention the action state machine or specific operations.

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

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

There is no guidance on when to use this tool versus alternatives, nor any conditionals like 'use start before update' or 'use get to retrieve current progress'. The description gives a general purpose but no practical direction for the agent on selecting or sequencing calls.

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

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

No annotations exist, so the description carries the full burden of behavioral disclosure. It mentions lazy-load triggering but does not explain side effects, the meaning of 'smart' or 'random' direction, what happens with amount=0, or whether scrolling may trigger network requests or wait for content. This is under-disclosed for an interaction tool.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently conveys the core action and key options before the schema details are needed.

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

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

With no annotations and no output schema, the description is too short to fully equip an agent. It lacks guidance on direction semantics, default behavior, when to invoke this tool, and what observable effects or return value to expect.

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

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

Schema description coverage is only 50%, so the description should compensate. It restates that direction, amount, and lazy-loading are configurable, but adds no new meaning beyond the parameter names and existing schema descriptions. It omits the 'smooth' parameter entirely and does not clarify the ambiguous 'smart' direction 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 names a specific verb ('Scroll'), a specific resource ('the page'), and the configurable aspects (direction, amount, lazy-load triggering). Among the sibling tools, none other is a scrolling tool, so this is clearly differentiated.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention conditions such as 'use when content is below the fold' or 'use for lazy-loaded pages', nor does it suggest a sibling tool for other cases.

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

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

With no annotations, the description carries the behavioral disclosure burden and does name the redirect mechanisms it follows and the return data. However, the claim that the result includes headers is at odds with the schema's includeHeaders default false, and it does not clarify whether tracing performs a live browser navigation that could affect the current session state.

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

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

Two sentences with no filler. The core action is front-loaded, and each clause adds useful information: which redirect mechanisms are tracked and what the tool returns.

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 core behavior and return summary are present, but because there is no output schema and no annotations, important context is missing: whether the path is a list of hop objects, how headers depend on includeHeaders, and whether the trace mutates the current browser page. The schema defaults help, but they do not fully compensate for these 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 coverage is only 57%, yet the description adds no parameter-specific guidance for the undocumented url, maxRedirects, or includeHeaders fields. The mention of returned headers conflicts with the includeHeaders default, and the redirect-type details do not explain how the followJS and followMeta booleans affect the output.

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

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

The description states a clear action ('Trace the complete redirect chain'), the concrete resource (a URL), and the exact tracking scope (HTTP 301/302, JavaScript navigation, meta refresh). It also states the return value, which makes it easy to distinguish this tool from browser-navigation or network-capture siblings.

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

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

The behavior implies the use case: analyze why a URL ends up where it does. However, the description never explicitly says when to choose this tool over alternatives such as replay_request or network_recorder, nor does it mention any exclusions or conditions.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It discloses two meaningful behaviors: execution happens inside the page context and session headers are reused. However, it does not state whether the request triggers navigation, whether the response is returned, or that re-sending a request may have side effects on the server.

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

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

The description is a single, focused sentence with no wasted words. The core scoping constraints, 'inside the page context' and 'reusing the current session headers', are front-loaded and immediately useful to an agent.

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

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

For a tool with four parameters, no annotations, and no output schema, the description omits significant contextual details: what the tool returns, whether it performs a page navigation, how body and headers interact with the original request, and whether replaying is safe. It gives a good one-line summary but is not complete enough for an agent to invoke it confidently in varied situations.

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

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

Schema description coverage is 0%, and the description mentions none of the four parameters (url, body, method, headers). It does not clarify how the headers parameter interacts with the reused session headers, what format body expects, or how the method default works. The description adds no parameter-level 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?

The description uses a specific verb ('Re-send') and a clear resource ('network request inside the page context'), and notes that it reuses the current session headers. It is distinct enough from siblings like navigate or execute_js, though it does not explicitly name an alternative.

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

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

The phrase 'inside the page context, reusing the current session headers' implies when to use the tool: when the agent needs to replay a request with existing session/auth state. However, it gives no explicit guidance about when not to use it, nor does it identify alternatives among the many 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?

No annotations are provided, so the description carries the burden of explaining behavior. It discloses the composite response, the ability to execute a steps array of actions without re-capturing, and the expected re-capture cadence. It does not explicitly warn that actions like click or type can mutate the live page, but this is strongly implied by the workflow.

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

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

The description is compact and front-loaded: the first sentence states exactly what is returned, and the second sentence gives actionable workflow guidance. There is no filler or repetition of schema details, 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?

The tool has 16 parameters, a complex nested steps array, and no output schema. The description gives a high-level return description and workflow, but it does not specify how the screenshot is returned, how the element map is structured, or how captureBefore/captureAfter defaults affect the response. These gaps are meaningful for an agent trying to consume the result correctly.

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

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

Schema description coverage is 94%, so the schema already documents most parameters. The description adds useful workflow-level meaning by recommending fullPage:true and annotate:true and explaining how the steps array should be used, but it does not add substantial per-parameter semantics beyond what the schema already states.

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

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

The description opens with a specific verb and resource: 'Capture a snapshot of the current page.' It then enumerates a concrete composite return value: screenshot, optional full-page text, interactive element map, and iframe inventory. This clearly separates it from navigation or isolated action tools, though it does not explicitly name a sibling it is not.

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 workflow paragraph is strong: it tells the agent to call once with fullPage:true and annotate:true, run all planned actions as a steps array, and not call see_page again until the page genuinely changes. This provides clear when-to-use and when-not-to-use guidance, though it does not explicitly contrast with sibling tools like click or type.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that the tool automates form completion and widget verification, but it doesn't disclose side effects like form submission, page interaction, retries, or the risk of triggering anti-bot protections. Key behavioral parameters such as submit, maxRetries, and humanLike are left to the schema rather than explained in the description.

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

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

The description is short and structured as two sentences without filler. It loses a point because 'interactive widget verification' is vague euphemism for captcha solving and the first sentence could more directly state the tool's unique purpose.

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

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

This is a complex tool with 19 parameters, no annotations, and no output schema, so the description must carry substantial context. It provides an overview of capabilities but omits return behavior, failure modes, and how it composes with the other browser automation siblings. An agent would need to infer important invocation context from the schema alone.

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 high (95%), so the baseline is 3. The description adds no parameter-level detail, but nearly every parameter already has a clear schema description, including the enum for type and selectors for captcha-specific targeting.

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 identifies the tool's verb (automate) and resources (form completion, interactive widget verification on web pages), and lists concrete supported capabilities like JavaScript challenge widgets and image text transcription. However, it doesn't explicitly differentiate itself from sibling tools like type or click, relying on the tool name and higher-level scope to set it apart.

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

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

There is no guidance about when to use this tool versus alternatives such as type, click, or execute_js. The mention of 'for QA and automated browsing workflows' provides a general audience but not conditions, exclusions, or alternative tool routing.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that save_session persists state and load_session restores it, but it omits important behaviors: what clear_cookies, indexeddb, and service_workers do beyond their names, whether load_session overwrites current state, whether save_session prompts or overwrites files, and any side effects on the active session. The mutating nature and potential side effects are not sufficiently disclosed.

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

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

The description is compact and well-organized as an action list. The opening sentence front-loads the core purpose, and the parenthetical explanations are short. It is efficient, though the last few actions receive no detail, making the list slightly uneven in 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 six-action tool with no output schema, the description is incomplete. It does not specify return values, required arguments per action, error cases, or the behavior of undocumented actions. An agent would need to guess what indexeddb and service_workers return or how they affect the browser. The tool is complex enough that more detail is necessary 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 50% (sessionPath has a description). The description adds meaning for three of the six action enum values (cookies, save_session, load_session), but leaves clear_cookies, indexeddb, and service_workers as bare names with no explanation. It does not clarify that sessionPath is only relevant for save_session/load_session, leaving the agent to infer parameter applicability. Partial compensation for schema 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 clearly states the tool's purpose: 'Inspect and manage client-side storage & sessions' and lists six specific action names with brief explanations for most. It identifies a unique domain (storage/sessions) that is distinct from sibling browser-automation tools, though it does not explicitly contrast itself with any sibling.

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

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

No explicit guidance is given about when to use this tool versus alternatives. The action descriptions imply some use cases (e.g., 'restore state from file without re-logging'), but there is no direct statement of when to prefer storage_inspector over other tools or when not to use it. Context is left entirely to the agent's inference.

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

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

With no annotations, the description carries the behavioral burden and does disclose configurable keystroke delay, field clearing, and iframe targeting. However, it omits other significant default behaviors such as waiting for the selector, AI-based selector healing, the option to press Enter, and the fact that clearing defaults to true.

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

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

A single front-loaded sentence communicates the core action and key capabilities with no filler or repetition. Every phrase earns its place.

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

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

For a 10-parameter tool with no annotations and no output schema, the one-sentence description is minimally adequate: it orients the agent and the schema fills the parameter details. Still, it leaves important contextual gaps around selector versus annotationId targeting, iframe selector/index options, and default wait/heal behavior.

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

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

Schema description coverage is 90%, so the schema already documents nearly all parameters. The description adds only a loose mapping to delay, clear, and iframe options and does not clarify the selector-versus-annotationId choice, but it does not need to compensate for missing schema documentation.

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

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

The description uses a specific verb-resource pairing, 'Type text into an input field', which clearly distinguishes it from navigation or clicking tools. It also names several option classes (delay, clearing, iframe support) that make the tool's scope evident, though it does not explicitly contrast it with siblings like press_key.

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

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

There is no guidance on when to choose this tool over alternatives such as press_key or click, nor any conditions or exclusions. The intended context is implied by 'input field' but never stated as a selection rule.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the four wait modes, which is substantive, but it omits meaningful behaviors: what happens when the selector is not found or the timeout elapses (error vs. continue), whether selector waits for appearance or visibility, and what 'networkidle' actually waits for. These are real unknowns for a tool that controls execution flow.

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

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

A single, front-loaded sentence with zero wasted words. It opens with the verb, immediately enumerates all four wait targets, and communicates the purpose in one pass — an agent can grasp the full scope at a glance.

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

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

The tool is simple with zero required parameters, and the schema defaults (type='timeout', timeout=30000) plus the description's type list cover basic invocation. However, the per-type parameter interplay, default behavior when only 'type' is supplied, and failure/error semantics are left unstated, which matters for a tool whose purpose is controlling the flow of a browsing session.

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

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

Schema description coverage is only 33% — only 'value' is documented in the schema, while 'type' and 'timeout' lack descriptions. The tool description adds value by enumerating the wait types and clarifying that the timeout value is in milliseconds, but it does not explain which parameters are required per type or how the 'value' field relates to the numeric 'timeout' parameter beyond the phrase 'timeout value in ms.'

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

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

The description states a specific verb ('wait for') and a clear resource scope: 'a selector, navigation event, networkidle state, or a fixed timeout before continuing.' These four wait targets map exactly to the schema enum, and no sibling tool performs a wait-like operation, so it is easily distinguished from navigate, click, and get_content without opening the schema.

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

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

The phrase 'before continuing' implies a synchronization use case between page interactions, which gives some contextual guidance. However, there is no explicit when-to-use explanation, no conditions for choosing one wait type over another, and no named alternatives — though no sibling provides a comparable wait capability, so the exclusion guidance is largely unnecessary.

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