svipall

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

Annotations already declare readOnlyHint=false and openWorldHint=false, indicating a non-read-only local cleanup operation. The description adds useful behavioral context by explaining that the browser is released and that sessions left open keep a browser running. It does not cover error or idempotency behavior, but for this simple close operation that is a minor 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?

Two tightly written sentences with no filler. The primary action is front-loaded, and the usage condition and consequence follow immediately.

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

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

For a simple one-parameter cleanup tool with no output schema, the description covers the essential action, trigger, and resource consequence. Annotations supply the safety profile, and the schema supplies the parameter meaning, so nothing critical is missing.

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

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

Schema description coverage is 100%, and the single session_id parameter is already documented in the schema as the value browser_open returned. The description reinforces that linkage but adds no format, validation, or edge-case meaning beyond the schema. Baseline 3 is appropriate when the schema carries parameter semantics.

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

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

The description names a specific verb and resource: close a session and release its browser. It explicitly ties the session to browser_open, distinguishing it from other browser-related 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?

It gives a clear trigger condition: call it when multi-step work is done. It also explains the consequence of not calling it, with sessions left open keeping a browser running.

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 declare readOnlyHint=false and openWorldHint=true, so the agent knows this mutates external state. The description adds that actions are performed in order and returns per-action results and page content, which is useful, but doesn't elaborate on destructive potential, required auth, or error behavior beyond the annotations.

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

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

Three sentences, front-loaded with purpose and key constraints, no filler. Every sentence earns its place by adding usage context or return info.

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 core usage, return values, and query filtering, and references sibling tools for session and snapshot. Missing details on error handling or action failure behavior, but adequate given rich schema and annotations.

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

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

Schema coverage is 100%, so the schema already documents all parameters thoroughly, including nested action properties. The description adds marginal value by restating 'omit url to keep acting' and query filtering, but baseline 3 is appropriate when schema does the heavy lifting.

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

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

States specific verbs (navigate, act) and resource (a browser session from browser_open), and explicitly ties to siblings web_act and web_snapshot. An agent can distinguish it from web_act (session vs new page) without opening schemas.

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

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

Explicitly says to omit url to keep acting on the current page and references the session from browser_open, giving clear context. However, it doesn't state when to choose this over web_act or browser_open directly, nor exclusions.

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 declare readOnlyHint=false and openWorldHint=true, so the agent already knows this creates state and reaches the network. The description adds genuinely new traits: the session is stealth and persistent, it is referenced by a returned session_id, cookies can be seeded from web_login via profile, and it must be released with browser_close. It stops short of disclosing resource cost or concurrent-session 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?

Four short sentences, front-loaded with the action and return value, then when-to-use, then the alternative, then lifecycle. No sentence is wasted.

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 opening, the session_id contract, cookie/profile reuse, the alternative tool, and the required teardown via browser_close. With no output schema needed beyond the stated session_id and full parameter coverage, nothing an agent needs to invoke this correctly is missing.

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

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

Schema description coverage is 100%, so all three parameters are already documented, including proxy, profile, and visible defaults. The description reinforces profile's link to web_login but adds no syntax or format detail beyond the schema, so the baseline 3 is appropriate.

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

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

States a specific verb+resource ('Open a persistent stealth browser session') and names the return value ('session_id for browser_do'), which lets an agent distinguish it from web_act, browser_setup, and browser_do without opening a 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?

Gives explicit when-to-use ('multi-step work where cookies and page state must survive between calls') with concrete examples (login then browse, cart then checkout), names the alternative for the simple case ('For one page and a few actions web_act is simpler'), and states both the profile-reuse path and the closing tool.

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 declare readOnlyHint=false and openWorldHint=true, so mutation and network access are already flagged. The description adds real value on top: the ~190 MB download cost, the default action (status), and the safety promise 'Nothing is downloaded unless asked' — behavior the annotations cannot express.

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?

Front-loaded with the action enumeration, then the trigger condition, then the safety note — a logical order with no filler sentences. The opening 'browser behind the browser, stealth, real and warm tiers' is mildly jargon-heavy, keeping it just under a 5.

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 only two fully documented parameters, no output schema, and minimal annotations, the description carries the burden well: it covers all four actions, sizes, defaults, and when to invoke. It does not describe the shape of the status output, but that is a minor gap for a setup 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 100%, so the baseline is 3, but the description goes beyond the schema's one-line summaries by explaining what each action does (status explains 'why', install downloads Chrome for Testing, update moves to current stable, remove deletes). That meaningfully enriches the action parameter.

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?

It names the resource (the browser binary behind the fetch stack) and enumerates each verb explicitly: status reports which binary would run, install/update/remove act on it. An agent can distinguish this management tool from the runtime siblings browser_open/browser_do without opening any 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 trigger is explicit: 'Use when a fetch or web_status reports no usable browser.' This names the alternative signal that should route the agent here. It lacks an explicit negative case (e.g., don't call when a browser already works), so it stops short of a 5.

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 readOnlyHint=true and openWorldHint=false already declaring the safety profile, the description adds real value by disclosing the possible status values (solved, processing, failed) and what the successful result contains (token or text). It doesn't mention polling behavior or timing expectations.

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

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

Two tightly written sentences with no waste; the identifying resource and the linking constraint come first, followed by the return-value 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?

There is no output schema, so the description carries the burden of explaining returns, and it does so adequately by naming the status values and the token/text payload. The only gap is polling/timing behavior for an async task checker.

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 100%, so the taskId parameter is already fully documented in the schema. The description reinforces the origin of taskId (returned by solve_* tools), which adds marginal meaning but not new syntax or format details. Baseline 3 applies.

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 (Check) plus resource (captcha task by taskId) and explicitly ties itself to the solve_* family of sibling tools. An agent can immediately distinguish this as the status-query counterpart to the solve tools.

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

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

It clearly establishes context: use this to check a task produced by solve_turnstile, solve_recaptcha_v2, solve_hcaptcha, or solve_image_captcha. No explicit when-not-to-use or polling-interval guidance is provided, so it falls short of a 5.

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?

Discloses a real behavioral trait beyond the annotations: outcomes order the strategies tried next time on that route, so the effect is persistent and feedback-driven. Annotations only say readOnlyHint=false. It could note idempotency or overwrite behavior, but the feedback-loop effect is the key non-obvious trait and is covered.

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

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

One dense sentence states the action, the payload, the key, and the reason to call it. No filler, and the routing instruction 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?

Complete enough for a small 3-param mutation tool with no output schema: action, post-condition, and the consequence of omission are all present. It stops short of 5 only because return behavior and error handling are not mentioned.

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 schema already documents good, note, and taskId fully. The description adds only the good semantics, which the schema also states. Baseline 3 is correct when the schema does the work.

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

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

States a specific verb (report) and resource (captcha outcome), with the boolean semantics spelled out (good=true worked, good=false rejected) keyed by taskId. The relationship to the solve_* family is explicit, distinguishing it from the solve 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?

Explicitly says when to call it: after submitting a token from solve_turnstile, solve_recaptcha_v2, or solve_hcaptcha. Also gives the when-not consequence: an unreported rejection is repeated because it feeds strategy ordering, which is a strong reason to always report.

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 declare readOnlyHint=false and openWorldHint=true but reveal nothing about the interactive/non-interactive distinction, the visible-window/dashboard fallback, or the session-bound nature of the challenge. The description adds all of these. It stops short of stating auth requirements or rate limits, so not a 5.

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 front-loaded with a distinct payload: what it does, why it beats siblings, when to reach for it, and what happens with stuck widgets. No filler.

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

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

For a 5-param mutation tool with no output schema but rich annotations, the description covers the full decision path (trigger, alternatives, return semantics, stuck-widget escalation) an agent needs to invoke it correctly. Nothing material is missing.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters, their defaults and formats. The description adds no per-parameter detail beyond what the schema provides. Baseline 3 is correct.

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

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

States a specific verb and resource ('Solve the captcha on a blocked page in place') and explicitly contrasts its return value with the three sibling solver tools (solve_turnstile, solve_recaptcha_v2, solve_hcaptcha) that return a bare token. This is exactly the differentiation needed when the sibling toolset contains four captcha solvers.

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?

Explicit trigger: 'Use after web_fetch returns `blocked_reason` with a captcha widget.' Explicit alternative guidance: 'The right choice whenever the goal is the content' vs the sibling solvers when only a token is needed. It even addresses the edge case of non-interactive vs human-required widgets and where to look (web_status).

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 only declare readOnlyHint=false and openWorldHint=true, so the description usefully adds the session/address constraint and the dual-mode behavior: it may return immediately with a token or return a taskId for a human-solved flow polled via captcha_status. It stops short of stating timeouts, cost, or failure modes, so it is strong but not exhaustive.

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

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

Three tight sentences with no filler: purpose first, then the routing constraint with its alternative, then the return shape. Every clause carries decision-relevant information and the discriminating constraint 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?

There is no output schema, so the description assumes the burden of describing returns and does so (token, or a taskId to follow with captcha_status). Combined with the documented required params and sibling routing, an agent has everything needed to invoke this 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 100% and both required parameters are documented in-schema (sitekey from the data-sitekey attribute, pageUrl the page the widget is on). The description merely references the same two inputs by name and adds no format or constraint detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ("Solve an hCaptcha challenge") plus the two inputs it consumes and the artifact it produces (the token). It also names the sibling it is not (solve_and_continue), so an agent can distinguish it from the adjacent captcha tools without opening any 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?

Explicitly narrows the use case ("Use only when you will submit the token yourself from the same session and address") and gives the alternative plus its selecting condition ("to read the page behind the challenge use solve_and_continue"). It further routes the async case to captcha_status.

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 only declare readOnlyHint=false and openWorldHint=false, so the description carries the interesting burden. It discloses the return shape ("Returns `text`, or a `taskId` to follow with captcha_status"), which reveals the async possibility and the follow-up tool, adding real behavioral value. It does not discuss rate limits or failure behavior, so it falls short of a 5.

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 tightly packed sentences: purpose, then usage routing, then return values. Nothing is redundant and the discriminating usage guidance is front-loaded after the core 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?

There is no output schema, so the description appropriately explains the return values (text or taskId plus the follow-up tool). Combined with full schema coverage and clear routing, an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, so both parameters are already documented, giving a baseline of 3. The description restates that the image may be base64 or a URL but adds no format, size, or encoding detail beyond the schema.

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

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

States a specific verb and resource: read characters in an image captcha and return them as text. It explicitly distinguishes itself from solve_and_continue, which handles challenge widgets on blocked pages, so an agent can disambiguate without opening either 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?

Provides a concrete when-to-use condition ("a form shows a picture of distorted characters you will type yourself") and an explicit alternative with its own trigger ("for a challenge widget on a blocked page use solve_and_continue"). Routing is unambiguous.

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

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

Beyond the annotations (readOnlyHint=false, openWorldHint=true), the description discloses a non-obvious constraint (same session/address), the dual return path (token or taskId to poll via captcha_status), and that a human may be involved. It doesn't mention credits, rate limits, or timeouts, so it stops short of a 5.

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 load-bearing: what it does, when to use it (with the alternative), and what comes back. Front-loaded with the operation and inputs.

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 output schema, the description carries the return-value burden and does so ('the token, or a taskId to follow with captcha_status'). Combined with the session constraint and routing to solve_and_continue, an agent has everything needed to invoke and follow up 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 covereage is 100% and the schema already documents pageUrl and sitekey with source detail (data-sitekey attribute). The description names the same two inputs but adds nothing about the optional 'invisible' flag, so it only matches, not exceeds, 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?

States a specific verb and resource ('Solve a reCAPTCHA v2 challenge') plus the inputs (sitekey, pageUrl) and the artifact produced (gRecaptchaResponse token). It also names the sibling it must not be confused with (solve_and_continue), so an agent can separate them without opening any 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?

Explicit routing is given: 'Use only when you will submit the token yourself from the same session and address; to read the page behind the challenge use solve_and_continue.' This supplies both the inclusion condition and the named alternative.

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

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

Annotations only declare readOnlyHint=false and openWorldHint=true, so the description carries the real behavioral burden and does so: it discloses the dual return mode (token vs. taskId) and that a taskId must be polled via captcha_status while a person solves it. It also reveals the session/address constraint, which is non-obvious. It stops short of stating timeout/failure semantics.

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 tightly packed sentences with the core action front-loaded, then the routing condition, then the return values. No filler; every clause conveys decision-relevant 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?

For a 2-param, no-output-schema tool, the description covers the action, the disambiguating alternative, the submission constraint, and the two possible return shapes including how to follow up on a taskId. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, with pageUrl and sitekey already documented (including the data-sitekey origin). The description names both parameters but adds no format, syntax, or sourcing detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb+resource (solve a Turnstile challenge) plus the inputs and output (token), and explicitly distinguishes itself from the sibling solve_and_continue. An agent can identify this tool from siblings without opening any 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?

Gives an explicit when-to-use condition ('only when you will submit the token yourself from the same session and address, such as a form posted with web_fetch method=POST') and names the alternative (solve_and_continue) with the condition that selects it (reading the page behind the challenge).

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 declare readOnlyHint=false and openWorldHint=true, so the general safety profile is partly covered. The description adds important session behavior ('one shot with no session'), the action repertoire, and return shape, but does not detail side effects, auth, or failure modes.

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?

Front-loads the purpose and the key alternative before listing action types. The action list is dense but necessary; overall it is appropriately sized, though it could be slightly more scannable.

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

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

For a complex browser-automation tool with no output schema, the description covers the one-shot limitation, snapshot prerequisite, action types, and return format. It omits error handling and some environment details, but the full schema and annotations cover much of the remaining context.

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 baseline is 3 even with no parameter info in the description. The description reinforces action structure and ref workflow, but adds little meaning beyond what the schema already documents for url, actions, tier, proxy, profile, timeout, and extraction.

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

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

States a specific verb and resource: opens a URL, runs actions, and returns the resulting page. It explicitly distinguishes itself from browser_open + browser_do for multi-step sessions, so an agent can tell it apart from 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?

Gives explicit when-to-use and when-not-to-use guidance: one-shot with no session, and for several steps on one login or cart use browser_open + browser_do. Also instructs taking a web_snapshot first and naming elements by ref.

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 only declare readOnlyHint and openWorldHint; the description adds the recording window after load, the fact that bodies are off by default because they are large (a cost disclosure), and the shape of what comes back. It does not cover the `profile`/auth implications or timing/rate behaviour, so it stops short of full 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?

Front-loaded with the core action and dense with useful detail; the workflow sentence and return-shape sentence both earn their place. Slightly long and clause-heavy, but no filler.

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

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

With no output schema, the description supplies the return contract (`endpoints` and `responses` with url, status, mime, and body when requested) plus default behaviours, so an agent has everything needed to call and interpret 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 already 100%, so a 3 is the baseline; the description goes beyond it by explaining the intent behind `pattern` (URL substring, omit first time), `bodies` (large, enable once the endpoint is named), and the interrogation sequence, adding real usage semantics.

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

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

States a specific verb and resource — recording JSON/XHR responses a page fetches during load and returning them — and contrasts it with the HTML-derived alternative and with link-following crawls. An agent can distinguish it from siblings like web_fetch or web_crawl without opening any 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?

Gives an explicit two-step workflow (call once without `pattern` to survey, then with `pattern` and `bodies=true` to retrieve) and a concrete selection rationale: find the real endpoint behind listing/pagination, and page=1 endpoints accept page=2, which beats following links.

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 openWorldHint. The description adds substantial context beyond that: robots.txt obedience, dedup defaults, resume semantics via crawl_id, saturation stopping, out_file changing the return shape to a path+count, and link-joining note. Does not cover rate limits or token/cost tradeoffs, so not a 5.

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?

Front-loaded main purpose is good, but the param rundown sentence is dense and lists roughly a dozen parameters inline, some of which (max_pages default 20, max_depth 2) repeat schema defaults. Informative but not tight.

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 23-param crawling tool with no output schema, the description covers the essential behavior an agent needs: scope, dedup, robots, resumption, saturation, output-shape switching. Return format is described at a high level (pages + crawl_id) which is sufficient since no output schema exists.

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 100% so the schema already documents all 23 params; baseline 3. The description still adds cross-field meaning: out_file changing return type, include-URL-substring, query+stop_when_saturated coupling, strategy=dfs use case, schema/tables producing rows, crawl_id resumption. Marginally above baseline but largely restates 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?

States a specific verb (crawl) and resource (one site from a start URL), and names the return (every page as markdown) with modifiers (deduplicated, robots.txt obeyed). Explicitly distinguishes from siblings web_fetch_many and web_map with the condition that selects each.

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?

Gives the core when-to-use ('pages are not known in advance') and two named alternatives with their own selection conditions: web_fetch_many when pages are known (cheaper), web_map for pre-crawl URL listing. Routes the agent without schema inspection.

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 openWorldHint, so safety is covered. The description adds genuinely new context: the comparison is a stored fingerprint rather than a fresh fetch, making it cheap, and it names the return shape. It doesn't elaborate on the refetch default/failure behavior, keeping it short of a 5.

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 tight sentences, front-loaded with what the tool does and its outputs, followed by routing guidance and a cost note. No filler and nothing that doesn't earn 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 two-parameter read tool with no output schema, the description names the returned fields (changed, similarity, added/removed blocks), the usage context, and the cost model. An agent has everything needed to select and invoke it correctly.

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

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

Schema coverage is 100%, so both url and refetch (with its default and false semantics) are already documented in the schema. The 'stored fingerprint, not a second full copy' line nudges toward the cached-comparison behavior but doesn't add syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Compare a page with the copy cached last time and return what changed') and even enumerates the returned fields. An agent can distinguish it from web_watch on the description alone.

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 scopes usage to 'a one-off question of whether a page changed since it was last read' and routes scheduled checking to the named sibling 'web_watch'. This is a textbook when-to-use / when-to-use-something-else statement.

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

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

Beyond the readOnly and openWorld annotations, it discloses the automatic tier ladder, per-domain tier memory, token-reduction options, default return fields, link handling, and blocked-response behavior. The instruction to act on blocked_reason/note and never retry blindly is important operational guidance.

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

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

The description is dense but front-loaded: purpose first, then default behavior, token controls, sibling routing, return fields, and failure handling. Every sentence contributes useful context for a 28-parameter fetch tool.

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

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

For a complex open-world fetch tool with no output schema, the description covers the main behavior, default return shape, blocked-case behavior, and sibling alternatives. The remaining parameter and output details are fully covered by the rich input 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 coverage is 100%, so the baseline is already strong. The description adds high-level semantics for key parameters such as query, css_selector, max_tokens/cursor, out_file, schema, tables, and mode, though the detailed per-parameter semantics still come primarily from 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 and resource: fetch one URL and return its main content as markdown, PDF/office, or rows via schema/tables. It also distinguishes itself from web_snapshot, web_capture, and web_fetch_many, so an agent can identify its role 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?

It explicitly calls itself the default way to read a page and explains that mode=auto should be used rather than set by hand. It names alternatives for clicking, JSON APIs, and multiple known URLs, giving clear when-to-use and when-not-to-use 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 cover read-only and open-world safety, while the description adds parallel execution, input-order results, one web_fetch result per URL, and corroboration output with duplicate marking. This gives substantial behavioral context beyond structured fields.

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 front-loaded sentences with no wasted language. Purpose, usage, and return behavior are all covered efficiently.

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

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

For an 8-parameter batch tool with no output schema, the description is complete enough: it covers purpose, when to use it, alternatives, and return shape. Annotations and the full parameter schema fill in the remaining safety and input details.

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 all parameters are already documented in the input schema. The description references the same query/schema/tables semantics as web_fetch but adds little parameter-level detail 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?

States a specific verb and resource: fetch several URLs in parallel. It clearly differentiates itself from web_fetch (batch) and web_crawl (discovery), so an agent can identify its role without opening another 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?

Explicitly says when to use it: when URLs are already known, from web_search, web_map, or a listing. It also names the alternative for discovery: web_crawl. No inference is required.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds real context beyond that: it explains what an event record contains and hints at a downstream action (resetting a learned tier). It stops short of noting pagination or volume characteristics, so it is not a 5.

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?

Front-loaded with the core purpose, then the two view modes, then the sibling contrast. The parenthetical about forget_tier is somewhat dense, but every sentence carries information and nothing is redundant filler.

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

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

No output schema exists, and the description covers enough about what is reported (which tier answered, which wall appeared, how long it took) for an agent to interpret results. A read-only, zero-required-parameter history tool does not need much more, though return volume is unaddressed.

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 100%, so the baseline is 3. The description exceeds it by giving semantic meaning to the 'summary' value — the signal of a learned tier gone wrong — which the schema merely labels as 'recent (default) or summary'. It does not clarify limit, domain, or since_secs 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?

States a specific verb and resource — reporting past activity per domain — and enumerates the payload (tier, wall, duration). It also explicitly contrasts itself with the sibling web_status ('web_status shows the current state; this is the history'), so an agent can separate the two without opening either 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?

Names both modes and their selection criteria: 'view=summary shows domains that are half blocked or slow... view=recent lists the last events.' It also routes to the sibling alternative and even names the remediation tool (web_status forget_tier) for the condition summary is meant to surface.

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=false and openWorldHint=true, so the mutation nature is known. The description adds substantial context beyond that: the window is visible, a human must act, behavior on profile omission (domain auto profile that later fetches pick up automatically), and reuse semantics. It doesn't state what happens if the timeout elapses without success, but that is a minor 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?

Front-loaded with the action, then the triggering condition, then the profile nuances and the sibling pointer. Every sentence carries information; no filler.

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

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

No output schema exists, and the description does explain the key side effect (cookies saved to a profile, later fetches reuse them). For a 3-param human-in-the-loop tool with annotations covering the safety profile, only the failure/timeout outcome is left implicit.

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 all three parameters are documented in the schema itself, and the description's notes on `profile` (auto profile vs. named reuse) largely restate it. It adds the cross-fetch consequence that later fetches pick the profile up automatically, but that is marginal over 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?

States a specific verb+resource (open a visible browser window) and the outcome (save cookies to a profile), which is clearly distinguishable from the solve_* captcha siblings and browser_open. An agent can tell this is the human-in-the-loop fallback rather than an automatic solver.

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 names the trigger condition: use when a fetch returns `blocked_reason` naming a login wall or a challenge no automatic tier clears, which routes the agent after the solve_* tools have failed. It also names web_profile as the tool for moving the profile to another machine.

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

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

Annotations already establish read-only and open-world behavior, but the description adds important context beyond them: it avoids fetching pages, lists the source types, highlights token savings versus crawling, and names the returned fields. It does not contradict the annotations.

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

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

The description is three dense sentences with no wasted text. The core purpose is front-loaded, followed by usage guidance and return information in a logical order.

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 output schema, the description usefully names the return keys (`urls`, `sources_used`, `sitemaps`, `feeds`) and tells the agent how to proceed with `web_fetch_many`. Combined with complete parameter descriptions, it is sufficient for an agent to call and interpret 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 description coverage is 100%, so all four parameters are already well documented in the schema. The description does not add syntax, format, or interaction details for url, limit, include, or sources 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?

States a specific verb and resource: list a site's URLs without fetching pages. It also enumerates the sources it maps (robots.txt, sitemaps, feeds, homepage links), which distinguishes it clearly from web_crawl and web_fetch_many.

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 to use it before web_crawl to decide what is worth fetching, or to find the page for a topic. It also names web_fetch_many as the follow-up for reading selected URLs, giving clear routing guidance.

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

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

Annotations only tell us it is a write-capable, non-open-world tool; the description supplies the key behavioral facts they omit — persistence across sessions, path-like key grouping, and prefix-based listing. It does not disclose whether set overwrites, note scope (global vs per-profile/site), or any TTL/size limits, which leaves real gaps for a stateful store.

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, fully front-loaded: purpose first, then a concrete use-case list, then the key-format convention. No filler sentences.

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 four actions, the persistence intent, and key structure for a 4-param, zero-required tool with no output schema. It does not describe return semantics for get/list (e.g. missing-key behavior or output shape), which the absence of an output schema would otherwise justify.

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%: value requirement for set, action meanings, and prefix semantics are all already documented in the schema. The description's path-like key example repeats the schema's own example rather than adding new meaning, so the baseline 3 applies.

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

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

States a specific resource (a cross-session value store) and enumerates all four verbs (set/get/list/delete) explicitly. No sibling tool (browser_*, web_crawl, web_search, etc.) does persistent storage, so it is easily distinguished 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?

'Use for state needed in a later session' gives a clear triggering condition, and the examples (last id seen, learned URL pattern, checkpoint) pin down the intended context. It does not name when NOT to use it or any alternative, so it stops short of a 5.

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 only say readOnlyHint=false and openWorldHint=false, so the description carries most of the burden. It usefully discloses that the archive is encrypted, that the password is required, and that no unencrypted form exists — meaningful behavior beyond the annotations, though it omits what import does if a profile already exists or whether export overwrites.

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 tight sentences, front-loaded with the core action, then the rationale, then the password constraint. Slightly compressed phrasing ('Use so a challenge a person passed once...') but every sentence earns its place.

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

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

For a 4-parameter tool with no output schema and thin annotations, it covers the three actions, the encryption guarantee, and where files land. Minor gaps remain around error/overwrite behavior, but nothing essential to invoking it correctly is missing.

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

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

Schema coverage is 100%, so parameters are already documented in the schema; baseline is 3. The description reinforces the required-password constraint and clarifies that list works on profiles saved by web_login, but adds little 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?

States a specific verb+resource ('Move a logged-in browser profile between machines') and enumerates the three modes export/import/list with what each does. It clearly separates this tool from the web_login sibling, which it names.

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?

Gives an explicit rationale for when to use it — so a challenge a person passed once with web_login is not repeated elsewhere — which is strong context. It does not explicitly state when to prefer list over export/import or any exclusion conditions, so it falls short of a full 5.

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 readOnlyHint=false and openWorldHint=true, the description adds key behavioral context: routing persists 'from now on,' subdomains inherit, remove drops the route, no arguments lists routes, and check tests exits for liveness, latency, and DNS leak. It also explains that country aligns browser timezone and language with the exit, which is valuable operational detail beyond the annotations.

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

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

The core action is front-loaded and the description is dense with useful mode and usage information. It is a long, semicolon-heavy paragraph with some repetition of schema details, but it remains readable and mostly 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 an eight-parameter routing tool with no output schema, the description covers purpose, modes, usage conditions, and the web_status alternative. It does not explain the return format for listing or check operations, but the rich schema descriptions and annotations compensate for much of that 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 100%, so the schema already documents all eight parameters in detail. The description restates some roles, such as proxies, countries, remove, and check, but adds little syntax or semantics beyond what the schema provides; baseline 3 is appropriate.

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

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

The description states a specific action: route one domain through a proxy or pool, with clear modes for remove, list, and check. It distinguishes those modes and points to web_status for health, so an agent can tell what this tool does 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?

It gives explicit use cases: when a fingerprinting wall never yields at any tier, or when a site is locked to a country. It does not provide when-not guidance or name an alternative tool beyond web_status for health monitoring.

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 (readOnlyHint=true, openWorldHint=true) already signal a safe open-world read, so the description doesn't need to restate safety. It does add real behavioral context: anti-bot handling is 'like web_fetch', the return is a path plus an inline image by default, and the inline PNG is skipped above 3 MB. No permission or quota details, but nothing is contradicted.

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 tightly packed sentences, front-loaded with the action and output, then routing, then flags. Every clause earns its place, though the flag explanations make it slightly denser than an ideal one-screen summary.

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?

There is no output schema, so the description carries the return-value burden and does: it states the returned path and the default inline image behavior, plus the 3 MB caveat. Combined with read-only annotations and 100% schema coverage, an agent has enough to invoke correctly; only niche details (tier semantics, proxy/profile interaction) are left to the 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 coverage is 100%, so the baseline is 3. The description goes slightly beyond the schema by explaining inline's 3 MB skip threshold and clarifying what full_page ('whole scroll height') and mobile ('renders it as a phone') actually change about the capture, which is genuinely useful framing for choosing flags.

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?

Names a specific verb and resource ('Save a PNG of a page rendered in a real browser') and immediately distinguishes it from siblings: web_snapshot for reading/acting, web_fetch for anti-bot handling parity. An agent can tell exactly what this produces (a PNG file path) 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?

Explicit both ways: 'Use when the question is visual: layout, a chart, an image, how a page looks to a person' and 'To read or act on a page use web_snapshot instead: cheaper, and it gives refs, whereas a screenshot cannot be clicked.' This is a clear when/when-not with a named alternative and the tradeoff that selects it.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the description is free to add the interesting traits: no API key required, first-answering-engine fallback, and merge-by-agreement under engine=all. It also bounds the payload ('not the pages'), though it does not discuss rate limits or result-quality caveats.

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 dense sentences, each doing distinct work: mechanism, workflow/routing, return shape. No filler and the scope statement 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 read-only search tool with no output schema, the description supplies the mechanism, the alternative tool, the downstream workflow, and the return fields (title, url, snippet). An agent has everything needed to select and call it correctly.

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

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

Schema coverage is 100% and all three parameters are documented there, including the engine values and the limit default/max. The description's engine note ('the first engine with results answers, engine=all merges them') largely restates the schema rather than adding syntax or format detail, so the baseline of 3 applies.

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

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

States a specific verb+resource ('Search the web') plus the mechanism ('reading public search engines' own result pages'), which distinguishes it from the fetch/crawl siblings. It also names the sibling it is not (web_site_search) for the single-site 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?

Gives explicit when-to-use ('find URLs for a topic'), the follow-up step ('then read them with web_fetch or web_fetch_many'), and an explicit when-not/alternative ('To search inside one site use web_site_search'). Routing is unambiguous.

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 cover safety (readOnlyHint, openWorldHint), and the description adds real behavioral value: it discloses the return shape (results_url plus the /search?q=... pattern) and the downstream consequence that later queries become plain web_fetch calls with no browser. It stops short of failure modes, timeouts, or what happens when a site has no usable search box.

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 dense sentences, front-loaded with purpose then alternatives then return value; the middle sentence carries the most weight but is somewhat listy ('shops, job boards and docs'). No filler sentences, though it is close to overpacked for a tool with a four-field schema.

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

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

There is no output schema, so the description must carry the return contract — and it does, naming results_url, the pattern, and the conditionally returned first results. Combined with annotations and a fully documented schema, an agent has everything needed to call this 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 coverage is 100%, so baseline is 3, but the description adds meaning: it explains that `url` is 'any page of the site' and ties `fetch` to a concrete outcome ('the first results while fetch is true'), clarifying what the flag buys rather than just restating its default.

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

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

States a specific verb (search) and resource (one site, via its own search box) and explicitly separates itself from two siblings: web_crawl ('a crawl reaches only what is linked') and web_search ('covers the whole web, not one site'). An agent can route correctly without opening any 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?

Gives an explicit when-to-use profile ('shops, job boards and docs whose content only appears when asked for') and names the two competing alternatives with the condition that disqualifies each. Nothing is left to inference.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description adds real behavioral context: deterministic, no image, a fraction of the tokens, and how find/max_depth narrow output. It stops short of covering auth/profile requirements or tier/timeout behavior, so it is strong but not exhaustive.

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

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

Four tight sentences, front-loaded with the resource and output shape, then routing rules, then token cost rationale. No filler and nothing repeated from structured fields.

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

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

With no output schema, the description correctly explains the returned nodes and how to reuse a ref, which is the critical return-value information. It omits guidance on tier/profile/timeout that matters for a 7-param open-world tool, so it is complete but not fully so.

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 each of the 7 parameters is already documented in the schema; the description only restates find and max_depth semantics. Per the baseline rule for high coverage, this is a 3 with no compensating detail 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?

States a specific verb and resource ('Read a page as its interactive structure: every button, link and field with its role, accessible name and a short ref') and names the siblings it displaces (web_fetch, web_screenshot). An agent can distinguish this from every other read-oriented sibling without opening a 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?

Gives explicit conditions: use instead of web_fetch when the next step is to click or type, instead of web_screenshot when a page must be understood, and pass a ref to web_act or browser_do. Both the selection rule and the downstream handoff are spelled out.

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 declare readOnlyHint=false and openWorldHint=false, so the agent already knows writes are possible. The description adds valuable nuance beyond that: 'Without arguments nothing changes' clarifies that inspection is non-mutating, and it names the four mutating parameters, which is genuinely useful context for a dual read/mutate 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?

Three sentences, front-loaded with the primary 'show current state' purpose, followed by usage guidance and the read-only-by-default caveat, then a sibling pointer. No filler or redundancy.

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

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

There is no output schema, and the description compensates by enumerating the returned state categories, so an agent knows what to expect. It lacks detail on how reset parameters interact or what the mutation returns, leaving a minor gap for a tool with five optional mutating 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 100%, so the schema already documents every parameter, and the description's note that clear_cooldown/forget_tier/clear_budget/clear_cache take a domain largely restates that. It adds no format or edge-case detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb ('Show') and resource (the current state) and then enumerates exactly what state is exposed (tiers, cooldowns, budgets, routes, sessions, crawls, solver stats, dashboard URL). It also distinguishes itself from the sibling web_log by naming it as the place for per-domain history.

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?

Gives a concrete trigger ('use when something is blocked or slow to see why') and frames the tool as the entry point for resetting state, plus routes to web_log for history. It does not spell out when-not-to-use or privilege requirements, so it falls short of a full 5.

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 only declare readOnlyHint=false and openWorldHint=true, so the description must add the interesting behavior – and it does: a no-op check costs one conditional request, watches persist across restarts but only run while the server is up, and a broken css_selector is relocated by fingerprint. It stops short of stating auth needs or what a change report looks like.

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?

Front-loads the core purpose in sentence one, then packs action semantics, cost, persistence limits and the alternative into three tight sentences with no filler.

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

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

With no output schema the description still conveys what list/check report and the cost model, and it covers persistence and the sibling alternative. Only the exact shape of a change report and any permission requirements are left unstated.

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 100%, so the baseline is 3. The description restates the interval_secs default and the action vocabulary rather than adding new syntax or format meaning beyond the schema's own descriptions, so it neither compensates for a gap nor adds much.

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

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

States a specific verb (watch) and resource (a page or one css_selector region of it) and immediately names the sibling it is not: web_diff for a single comparison. An agent can distinguish it from web_diff/web_snapshot without opening any 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?

Enumerates each action (add/list/check/remove) with its meaning, and explicitly routes the no-watch single-comparison case to web_diff. That is an explicit when-to-use plus an alternative, leaving little to inference.

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