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

No annotations are provided, so the description carries the full behavioral burden, but it only says what a click is. It does not disclose actionability waits, stale-ref behavior, failure modes, or whether the click can trigger navigation or dialogs.

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 single sentence is front-loaded and free of filler. Its brevity is efficient, although the resulting under-specification is captured 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 an action tool with no annotations, no output schema, and five parameters at 40% description coverage, the description is too thin. It omits prerequisites, side effects, and most parameter semantics that an agent needs to invoke it correctly.

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

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

Schema description coverage is only 40%, and the description adds no meaning beyond the target schema, which already explains refs and selectors. It does not clarify button, modifiers, doubleClick, or element usage, so it fails to compensate for the low 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 states a specific verb and resource: "Click an element," with the accepted target forms "ref or selector." This clearly separates it from siblings like browser_type or browser_hover, though it does not explicitly name those alternatives.

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

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

It gives no guidance on when to use this tool versus alternatives such as browser_hover or browser_fill_form. It also omits prerequisites, notably that a ref like e3 requires a prior browser_snapshot.

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. 'Buffered' hints that accumulated messages are returned, but it does not state whether the buffer is consumed/cleared, whether messages persist across tabs/navigations, or how level/limit affect the result. For a read tool with zero annotation coverage this is a real 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?

A single efficient sentence with the resource front-loaded. It is not bloated, though the terseness contributes to the specification gaps noted elsewhere.

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 annotations, no output schema, and two undocumented parameters leave the agent without enough context to call this correctly. The description should at minimum cover filtering, ordering, and buffer 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 0% and the description says nothing about the two parameters. It does not explain the 'level' enum values or which are included by 'all', nor the default/meaning of 'limit', so it fails to compensate for the documentation gap.

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

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

Names a specific verb (Retrieve) and resource (buffered console/pageerror output) with a clear scope (active tab). No sibling tool retrieves console output, so an agent can identify it, but the description does not explicitly contrast it with siblings like browser_evaluate.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as browser_evaluate. The use case is only implied by the resource name.

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

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

With no annotations, the description carries the full behavioral burden and discloses almost nothing beyond the action verb. It does not say whether this uses HTML5 drag events or mouse events, whether source/target must be scrolled into view, whether the operation waits for completion, or what happens if the source is missing.

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

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

One short, front-loaded sentence with zero filler — but for a 4-parameter tool with confusingly overlapping parameter names, this level of brevity reads as under-specification rather than tightness.

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?

A multi-parameter interaction tool with no annotations, no output schema, and only 25% schema coverage needs the description to fill several gaps (parameter disambiguation, prerequisites, failure semantics), and it supplies none of them.

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 25%; startTarget is documented and endTarget inherits that text via $ref, but startElement and endElement are completely bare and the description does nothing to explain why both a 'Target' and an 'Element' variant exist or when each should be used. This ambiguity is exactly what the description should resolve and it does not.

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 ('drag') and its two endpoints ('from one element to another'), so the agent immediately knows this is a pointer-based drag interaction rather than a click or hover. It does not name or distinguish itself from the obvious sibling browser_drop, but the resource/verb pairing is unambiguous.

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

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

No when-to-use guidance, no prerequisites, and no mention of the sibling tools that overlap with it (browser_drop, browser_click). It also omits the practical requirement implied by the schema that element refs typically come from a prior browser_snapshot, so the agent gets no routing help.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: whether the drop dispatches real dragenter/dragover/drop events, whether it requires a prior drag, whether it mutates page state, or what happens on failure are all unstated. The schema's 'synthetic drag-drop' phrasing is the only extra hint, and that lives in a parameter, not 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?

One short, front-loaded sentence with no padding, which is structurally fine. But it is under-specified rather than truly concise — the brevity comes at the cost of any operational 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?

For a four-parameter browser interaction tool with no annotations and no output schema, the description is too thin: it omits prerequisites, the relationship between the data and paths parameters, and any behavioral expectations. An agent could guess, but would likely need to experiment.

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 documented inline, including the target ref format and the MIME-to-payload map. The description adds no additional meaning about how data, paths, and target interact (e.g. whether both data and paths can be supplied together), 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 (drop) and resource (files or data onto an element), which is clearer than a bare name restatement. However, it never distinguishes itself from the sibling browser_drag, whose name sits adjacent and could plausibly be confused with this 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?

No when-to-use guidance at all: no mention of prerequisites (e.g. that a drag must be initiated first), no statement of when to prefer this over browser_drag, browser_file_upload, or browser_fill_form. The agent must infer the tool's role from the name alone.

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

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

With no annotations, the description carries the full burden, and it does disclose important state semantics beyond the schema ('Omitted parameters are left unchanged; null clears an override'). It still omits whether the override persists across navigations, whether a page must already be loaded, and whether the effect is reversible.

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

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

Two tight sentences, front-loaded with the purpose and then the state semantics. No filler; every clause carries 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 no-output-schema, no-annotation tool with five optional params, the description covers purpose, an example, and reset semantics adequately. Gaps around persistence and required page state are minor but real.

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 adds meaning the schema does not: the null-vs-omitted semantics (null clears, omission leaves unchanged). This is directly parameter-relevant and goes beyond the type-level schema definitions.

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 ('Emulate') and resource ('CSS media features') with a concrete example ('switch between the light and dark color scheme'). The resource is distinct enough from siblings like browser_resize (viewport) that an agent can tell them apart, though the description never names an alternative explicitly.

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 example implies you reach for this tool when you want to test dark/light schemes, so usage is inferable. However there is no explicit when-to-use, no when-not-to-use, and no comparison against related siblings like browser_resize or cloak_set_fingerprint.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose that this executes arbitrary code in page context, whether it can mutate page state or side-effect the DOM, what happens on errors, or any security implications. For an arbitrary-execution tool this is a significant disclosure 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 short sentences, zero waste, with the core action front-loaded. Nothing redundant is included.

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 must carry the full load, yet it omits the risk profile of arbitrary code execution, return behavior, and the purpose of the 'element' parameter. For a powerful eval tool with three parameters, this is under-specified.

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%: the 'function' and 'target' parameters have descriptions in the schema, while 'element' has none. The description repeats the arrow/function-expression constraint already present in the schema, adding little. Baseline 3 is appropriate given the schema does most of 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?

The description states a clear verb and resource: 'Run a JavaScript function inside the page.' An agent can understand the core action. However, it does not differentiate this tool from siblings like browser_snapshot, browser_find, or browser_click, which are the safer declarative alternatives for interacting with a page.

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 reach for this tool versus the many declarative browser_* siblings (click, type, find, snapshot). The only constraint given is about function syntax, not usage context. An agent gets no help deciding alternatives.

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

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

No annotations are provided, so the description carries the full burden. It does disclose two useful behavioral facts not in annotations: the tool requires an active file chooser dialog, and paths are constrained by --upload-allow-dir. However, it says nothing about failure modes, whether prior selections are replaced, or how errors surface.

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

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

Two tight sentences with the core action front-loaded and the constraint as a follow-up. No filler; every clause 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 single-parameter action tool with no output schema and no annotations, the description covers the essential precondition and the path constraint. It is nearly complete, with only error/replacement behavior left unspecified.

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 there is only one parameter, so the schema already documents 'paths' fully. The description's path-constraint sentence duplicates the schema rather than adding syntax or format detail. 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 (upload) and resource (files) with a clear target (the active file chooser), which distinguishes it from siblings like browser_drag and browser_drop. An agent can tell immediately what this tool does and where it acts.

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 'active file chooser' implies the precondition that a file chooser dialog must already be open, but the description gives no explicit when-to-use guidance or alternatives (e.g., browser_drop for drag-drop scenarios). Usage is only implied.

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

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

With no annotations, the description carries the full behavioral burden and delivers almost nothing. It does not say whether populating triggers change/blur events, whether it submits the form, what happens on a missing target, or how errors in one field affect the rest of the batch.

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 short sentence, front-loaded with the core action. It is efficient, though the brevity here reflects under-specification rather than disciplined editing.

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

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

No annotations, no output schema, and a nested-array parameter make this a complex tool, yet the description covers none of the missing pieces: batch semantics, failure behavior, interaction with browser_snapshot refs, or whether the form is submitted.

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

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

Schema description coverage is 0% for the parameter as reported, and the description adds no meaning beyond 'form fields'. It never explains the fields array structure, the role of 'kind', or that 'target' accepts snapshot refs or Playwright selectors — that detail exists only inside the nested 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 ('Populate') and resource ('form fields') plus a batch scope ('multiple ... in one call'). This implicitly separates it from the single-field sibling browser_type, but it never names that sibling or otherwise explicitly differentiates itself.

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

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

The phrase 'in one call' hints at batch usage, but there is no explicit when-to-use, when-not-to-use, or named alternative such as browser_type for single fields. An agent must infer the routing decision entirely from the word 'multiple'.

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

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

With no annotations, the description carries the burden and does well: it discloses the return format, the path-from-root context lines, and the cost advantage. It omits the filename side effect (writing to a file instead of returning) and any read-only reassurance, which keeps 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?

A single dense sentence with the purpose, return shape, and cost rationale front-loaded. Nothing wasted and 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, so the description explains what comes back (matching nodes with context under their paths). Combined with fully documented parameters, 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 coverage is 100%, and the schema already documents text, regex, case sensitivity, flags, and mutual exclusivity. The description only references 'text or a regular expression' generically, adding no meaning 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 (Search) and resource (accessibility snapshot of the current page), plus the return shape (matching nodes with context, under their path from root). It distinguishes itself from browser_snapshot by noting it is cheaper when you only need to locate an element and its ref.

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 frames the use case: use this over a full snapshot when you only need to locate an element and its ref. It does not spell out a when-not, but the comparison to browser_snapshot gives an agent clear selection signal.

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

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

With no annotations, the description carries the full behavioral burden. It names dialog types but omits the key semantics: whether accept=false dismisses the dialog, that promptText only applies to prompt dialogs, what happens if no dialog is pending, or whether the action is reversible.

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 filler; the parenthetical enumeration is efficient. It is terse to the point of under-specification, but nothing 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?

For a disabled-annotation, 0%-coverage, 2-parameter mutation tool with no output schema, the description is too thin. Neither parameter semantics nor the dialog lifecycle is covered, so an agent lacks what it needs to call it correctly in 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 coverage is 0% and both parameters are bare (accept: boolean, promptText: string). The description clarifies nothing about the accept/promptText pairing or the dismiss-vs-confirm meaning, leaving the agent to guess how to fill them.

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 ('Respond') and resource ('the next dialog'), and enumerates the dialog types (alert/confirm/prompt/beforeunload), so the agent immediately knows the operation. It does not explicitly contrast itself with siblings, but no other tool in the list concerns dialogs, so the distinction is effectively unambiguous.

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

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

There is no guidance on when this must be called: it does not say a dialog blocks page interaction, that it should be invoked after a dialog is triggered, or how it relates to other browser tools in the flow. 'Next dialog' hints at queuing order but no when/when-not condition or alternative is given.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses essentially nothing beyond the bare action. It does not say whether the hover triggers page effects, whether it waits for resulting UI, whether it holds the pointer position, or what happens if the element is not visible.

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

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

A single front-loaded sentence with no filler and no wasted words. It is arguably under-specified rather than bloated, but as pure conciseness it is efficient.

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

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

With no annotations and no output schema, this three-word description leaves the agent without any behavioral or usage context for a stateful browser interaction. An agent cannot tell from the definition when hovering is appropriate, what side effects to expect, or how to interpret failure.

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 `target` (element ref or Playwright selector) and `element` (logging-only description) are already fully documented in the schema. The description adds no parameter information, 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 (hover) and resource (element), which is unambiguous and readily distinguishable from siblings like browser_click, browser_drag, and browser_type. It lacks any explicit sibling differentiation or scope statement, but the action itself is self-evident.

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 when-to-use or when-not-to-use guidance. There is no mention of the common reason to hover (revealing tooltips, dropdown menus, hover-activated controls) nor any note about which sibling to use instead when interaction is not a simple pointer-over.

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

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

With no annotations, the description carries the full behavioral burden. It helpfully discloses that navigation returns a fresh snapshot, but it omits failure behavior, timeout handling, and what happens when a URL is blocked by domain restrictions.

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

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

The description is two sentences, front-loaded with the main action and immediately followed by the return behavior. There is no redundant or wasted text.

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 navigation tool with no annotations, no output schema, and only 33% schema description coverage, the description is too sparse. It should explain the undocumented waitUntil and timeoutMs parameters and mention domain-restriction behavior to be complete.

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

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

Schema coverage is only 33%: url is documented, but timeoutMs and waitUntil have no schema descriptions. The tool description adds no parameter-level meaning, leaving two of three parameters undocumented in both schema and prose.

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: 'Load a URL in the active tab.' This clearly identifies the navigation action, though it does not distinguish itself from sibling tools such as browser_navigate_back or browser_tabs.

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

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

Usage is implied by 'Load a URL in the active tab,' but the description gives no explicit guidance on when to choose this over browser_navigate_back, browser_tabs, or browser_snapshot, nor does it mention prerequisites.

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, so the description carries full burden. It states the basic action but omits edge cases (no history), wait behavior, or any safety context. Minimal behavioral disclosure.

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

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

Single sentence, front-loaded, zero waste. Appropriate size for a simple zero-parameter tool.

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

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

Given low complexity and no annotations/output schema, the description covers the core action but lacks edge-case or prerequisite detail (e.g., behavior when no history exists). Adequate but incomplete.

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

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

Zero parameters, so baseline 4 applies. The description needs no parameter details, and none are provided.

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: 'Go back' on 'active tab's history'. Clear, though it doesn't explicitly distinguish from sibling browser_navigate (forward) or mention any 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?

No guidance on when to use this versus browser_navigate or other navigation tools. No prerequisites or conditions mentioned; the implied usage is self-evident but not articulated.

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 entire behavioral burden. 'Single key or key combination' hints that held/repeated keypresses are not supported, but it says nothing about the focus requirement (does a focusable element need to be active?), whether events dispatch to the focused element or document, or any return value.

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 no wasted words. It is arguably over-terse for a tool whose behavior depends on focus state, but as pure structure it is clean and readable.

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

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

For a one-parameter tool with full schema coverage and no output schema, minimal text is defensible, but the description omits the interaction precondition (focus) that an agent needs to call this correctly in a page-level keyboard 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 schema already documents the key parameter with Playwright key syntax examples. The description's 'single key or key combination' loosely maps to that but adds no new syntax or format 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 (send) and resource (key/key combination) and scopes it to 'page level', which distinguishes it from element-targeted interaction tools like browser_type. It does not, however, name or contrast with any sibling explicitly.

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 when-to-use guidance, no prerequisites, and no alternative named. An agent must infer on its own that this is for keyboard shortcuts or key events versus browser_type for text entry into a field.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: no units (pixels vs CSS px), no note on whether the change persists across navigation or affects screenshots, and no reversibility or permission context. It only implies a state mutation of the viewport.

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 single sentence is front-loaded with the verb and object and contains zero filler. It is efficiently structured, though its brevity borders on under-specification rather than deliberate concision.

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-required-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, the definition should at minimum state units and interaction with other browser state. As written, an agent cannot call it confidently without guessing what the numbers mean.

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

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

Schema description coverage is 0%, so the description must compensate for the two undocumented required parameters, and it does not — width and height are never mentioned, and no unit, range, or format guidance is given. The parameter names are self-evident, which keeps this from being a 1, but no added meaning is supplied.

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 (resize) and resource (the viewport), so an agent immediately knows this changes the browser viewport dimensions rather than page content. It does not, however, distinguish scope or units, nor reference any related sibling such as browser_emulate_media or browser_take_screenshot, so sibling differentiation is absent.

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 indication of when to reach for this tool, under what preconditions (e.g. after navigation, before a screenshot), or what alternatives exist. The terse statement leaves all usage context to inference.

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

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

With no annotations, the description carries the full burden and discloses almost nothing: it does not say whether scrolling is instant or smooth, whether it waits for scroll-triggered lazy loading, what happens with a stale or missing element ref, or how direction interacts with amount. Only the basic mutation of viewport position is implied.

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

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

One short, front-loaded sentence with no filler. The verb and resource lead, and nothing 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?

For a tool with four parameters, no annotations, and no output schema, the description is too thin. It omits scroll mechanics, the page-vs-element targeting rule implied by a required target, direction defaults, and any note on waiting or ref freshness.

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 75% and already documents amount's default (600), the target ref/selector forms, and element's logging-only role, so the baseline is 3. The description restates the amount semantics ('by a pixel amount') without clarifying the biggest ambiguity it raises: target is required, so how does one scroll 'the page' rather than an element? Direction's default and axis behavior are also unexplained.

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 (scroll), the two resources it can act on (the page or an element), and the unit of motion (pixels). An agent immediately knows what this does, though it offers no differentiation from sibling viewport tools like browser_resize or browser_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?

There is no guidance on when to scroll versus using browser_snapshot, browser_find, or browser_wait_for to bring content into view, and no mention that target refs come from a prior snapshot. The agent must infer the workflow entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether selection dispatches change events, how it waits for the element, or what happens if a value is not found in the dropdown.

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 no waste. Brevity here reflects under-specification rather than tight editing, but structurally it is sound.

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 3-parameter mutation-style tool with no annotations and no output schema, the description omits matching semantics for values, failure behavior, and event/wait characteristics an agent needs to call it correctly.

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

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

Schema coverage is 67%: target and element are documented, but the values array is not. The description adds only the hint that multiple options can be selected, without clarifying whether values match option value, label, or index. Baseline 3 for moderate 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?

States a specific verb and resource ('Select ... in a <select> dropdown'), which is unambiguous. It doesn't distinguish itself from near siblings like browser_click or browser_fill_form, but the dropdown-specific framing is clear enough.

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

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

No guidance on when to use this instead of browser_click, browser_type, or browser_fill_form, and no prerequisites (e.g., that the select must already be visible). Usage is only inferable from the name.

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 load. It usefully discloses the return payload format (structured outline with [eN] refs) and the fact it targets the active page, but says nothing about side effects, size/truncation behavior on large pages, or whether it is a pure read.

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

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

Two tight sentences, front-loaded with the action and immediately followed by what it returns and how to use it. 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 covers the essential return shape (accessibility tree as structured outline with refs), which is the key thing an agent needs. Missing only edge-case guidance like large-page behavior or ref invalidation.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a 0-param tool applies. The schema is empty and fully consistent with the description.

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

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

The description gives a specific verb and resource: "Capture an accessibility-tree snapshot of the active page," which is clearly distinct from browser_take_screenshot and browser_find. It does not explicitly name a sibling to differentiate against, so it stops 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?

"[eN] refs you can pass to interaction tools" implies this is the prerequisite step before click/type, but the description never states when to use it versus browser_take_screenshot or browser_find, nor any 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?

No annotations are provided, so the description carries the full behavioral burden and it does not deliver: it never says that 'close' destroys a tab and its state, whether switching changes the active context for subsequent calls, or what 'list' returns. For a tool containing both read and destructive operations with zero annotation coverage, this is a substantial 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?

A single front-loaded sentence with no filler, and the operation list is easy to scan. It is arguably too terse, but that shortfall is captured in the other dimensions rather than being a structural flaw.

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 four parameters, no output schema, no annotations, and both mutating and destructive actions, the description should explain the close/switch semantics and what listing returns. It covers only the bare enumeration, leaving the agent without enough context to use the tool confidently.

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 75% and the schema already documents id, url, and index thoroughly, including the id-takes-precedence rule. The description's enumeration of the four actions merely restates the action enum and adds no parameter meaning beyond it, so it does not compensate for the uncovered fourth 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?

The description names a specific resource (tabs) and enumerates the four operations (list, create, switch, close), so the agent knows exactly what domain this covers. It does not reference any sibling, but no sibling tool handles tab lifecycle, so differentiation is implicit rather than stated.

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 versus the many browser_* siblings (e.g., browser_navigate vs action=new), nor any prerequisites such as needing an open browser session. The agent must infer that tab management is a separate concern from navigation.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the basic action. It does not describe the return format (e.g., binary image data or path), whether the tool waits for rendering, or any side effects or permissions required.

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. However, its extreme brevity borders on under-specification for a tool with six parameters and no annotations.

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 six parameters, no annotations, and no output schema, the description is not complete enough for an agent to invoke the tool confidently. Critical details like default format, quality behavior, fullPage semantics, and return value are missing.

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

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

Schema coverage is only 33% (only saveAs and target have descriptions), and the description does not compensate. It vaguely mentions 'a specific element' but does not clarify the difference between the 'target' and 'element' parameters or explain type, quality, and fullPage options.

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

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

The description states a specific verb ('Capture') and resource ('screenshot') and clarifies the scope ('of the page or a specific element'). It clearly distinguishes what the tool does, though it does not explicitly differentiate this from sibling tools like browser_snapshot or browser_find.

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

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

No guidance is provided on when to use this tool versus alternatives such as browser_snapshot or browser_find. It also fails to mention prerequisites like page load state or whether the screenshot captures the viewport by default.

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

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

With no annotations, the description carries the full behavioral burden. It says nothing about whether existing field content is cleared, whether the element is auto-focused, whether typing fires keystroke events, or what happens on failure — all material for an interaction tool. The one behavioral hint it does offer references a flag that isn't in the schema.

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

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

Two short sentences, with the core action front-loaded before the modifier. It is tight and earns its length, though the second sentence spends its budget on a flag that does not exist rather than on useful 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?

For a 5-parameter interaction tool with no annotations and no output schema, the description covers almost nothing: no side effects, no prerequisites (e.g. that target refs come from browser_snapshot is only in the schema), no interaction guidance with submit/Enter behavior, and it never resolves the --humanize/slowly discrepancy.

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 80% and the schema already documents target, element, submit, and slowly, so the description need not repeat them. Instead of adding meaning, the description introduces '--humanize', a parameter that does not appear in the schema, which can lead an agent to emit an invalid call.

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 ('Type text into an editable field'), which is clearly distinct from sibling tools like browser_click or browser_navigate. It stops short of differentiating itself from the closest sibling browser_fill_form (bulk form filling), so it is clear but not fully disambiguated.

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

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

The only usage guidance is 'Use --humanize for natural per-character timing', but --humanize does not exist in the input schema; the analogous parameter is 'slowly'. Guidance that points at a nonexistent flag is misleading rather than helpful, and there is no statement of when to prefer this tool over browser_fill_form or browser_press_key.

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

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

No annotations are provided, so the description carries the full burden. It says the tool waits for conditions but does not state whether it blocks execution, how default timeouts behave, what happens on timeout/failure, or what the tool returns. These are important behavioral traits for a wait 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 is appropriately concise, though its extreme brevity leaves important details to the schema and makes it less informative than it could be.

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

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

Given six parameters, 0% schema description coverage, no annotations, and no output schema, the description is too thin. It does not explain how the wait modes map to specific parameters, default timeout behavior, or the result of a successful or failed wait.

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

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

Schema description coverage is 0% for all six parameters, so the description must compensate. It names broad concepts that correspond to some parameters (time, text, selector state), but does not clarify timeoutMs, textGone, or the state enum values, leaving most parameter semantics undocumented.

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

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

States a specific verb ('Wait for') and the three condition categories (time, text appearance/disappearance, selector state), which maps to the tool's parameters. It is clear enough to distinguish from sibling browser_* tools, but does not explicitly contrast with alternatives like browser_find or browser_snapshot.

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

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

The description implies the tool is used to wait for certain conditions, but it gives no guidance on when to choose it over browser_find, browser_snapshot, or other siblings, nor when each wait mode is appropriate. No prerequisites or exclusions are mentioned.

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

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

No annotations are provided, so the description carries the disclosure burden; it does convey that this is a passive report of four specific fields, implying a safe read. It does not state whether it hits disk/network, how fast it is, or what happens if no binary is installed.

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 listing exactly the four returned fields 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?

There is no output schema, and the description compensates by enumerating the returned fields (version, tier, platform, cache path). For a zero-argument read tool that is nearly complete, missing only failure-mode 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate — the baseline of 4 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?

Specific verb ("Report") plus a concrete set of resources (binary version, tier, platform, cache path). An agent can distinguish this read-only inspection tool from cloak_binary_update, though the description never names that sibling explicitly.

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

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

Usage is only implied — the diagnostic nature suggests calling it to check the installed binary before/after an update, but no when-to-use or when-not conditions and no named alternatives are given.

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

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

With no annotations, the description carries the full behavioral burden. It does add genuinely useful operational context that structured fields do not provide: the operation may take several minutes and downloads roughly 200MB. It omits whether network access is required, whether the download is resumable or fails on partial progress, and whether an existing browser session is affected.

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, both earning their place, with the action front-loaded and the cost caveat immediately after. No filler, no restatement of the tool name.

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

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

For a zero-parameter tool with no output schema and no annotations, the description covers the essential action plus the notable time and size cost. It is nearly complete, lacking only prerequisites (network, restart behavior) and any hint of what a successful result looks like.

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

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

The tool takes no parameters, so there is nothing for the description to disambiguate; baseline 4 applies. Schema coverage is reported at 100% and the input object is empty, matching the description's parameterless nature.

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 gives a specific verb and resource: force CloakBrowser to check for and download the latest Chromium build. It is clearly not a navigation or fingerprint tool. It stops short of naming the closest sibling, cloak_binary_info, so the agent must infer the boundary between inspecting and updating the binary.

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 word 'Force' implies this is used when the agent wants to update rather than merely inspect the binary, which gives implied context. However, there is no explicit when-to-use statement, no mention of checking the current version first (cloak_binary_info), and no conditions under which this should be avoided.

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

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

No annotations are supplied, so the description carries the full burden. It does not disclose that this makes live requests to third-party probe sites, that results may be blocked or require waiting, or what 'key result fields' actually contains. The only side-effect hint comes from the schema's note that sannysoft is 'free, no captchas', which implies other suites are heavier but is not surfaced 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?

A single efficient sentence, front-loaded with the action and resource, with no filler or repetition.

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

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

With no annotations and no output schema, the description is the only source of behavioral and return-value information, and it supplies almost none. An agent cannot tell what fields come back, whether the call is slow, or whether third-party network egress is involved.

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 enum lists all five probe types with a default noted, so the schema already does the parameter work. The description adds nothing about suite or customUrl semantics, 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: loading a known bot-detection probe page and dumping its key result fields. That is far more informative than the tool name alone, but it does not distinguish itself from the sibling cloak_stealth_audit, which an agent could easily confuse it with.

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 explicit when-to-use, when-not-to-use, or alternative named. The description implies a bot-detection testing context but never says whether this is for validating a fingerprint configuration versus auditing one's own setup, nor how it relates to cloak_stealth_audit.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the directory location and the word "fresh," but is silent on the critical case of a duplicate name (error vs overwrite), permissions required, and whether the operation is reversible. For a creation/mutation tool this is a notable 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 short, front-loaded sentences with no wasted words. The primary action is stated first, with the follow-up usage note second.

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 would need to explain the return value, and with no annotations it should cover the safety/error profile. It covers the essential location and workflow but leaves the duplicate-name outcome and return value unstated, making it only adequately complete.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does by showing <name> is interpolated into the profile path, but it does not explain the allowed character set (the schema pattern does that) or constraints on the name. Only partial compensation.

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

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

States a specific verb (create) and resource (persistent profile directory) with the exact target path, so the agent knows precisely what the tool produces. It does not explicitly distinguish from the sibling list/delete tools, but the verb makes the distinction reasonably clear.

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

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

The second sentence ("Use as --profile-dir on next launch") hints at the intended workflow, implying the tool is a prerequisite before launching a persistent session. However, it says nothing about when to prefer this over alternatives or what happens if a profile of the same name already exists.

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

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

With no annotations, the description carries the full burden. It does disclose the destructive action, the confirm safeguard, and the scope caveat that the active session is unaffected. It omits irreversibility, whether it fails if the profile is in use, and the persistence implications of a 'persistent' profile.

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 very short sentences, front-loaded with the action, then precondition, then impact. Every sentence earns its place with no filler.

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

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

For a destructive operation with no annotations and no output schema, the description is thin but serviceable: action, precondition, and one scope caveat. It leaves the meaning of 'name' and the failure/consequence behavior (irreversibility, in-use profiles) 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 50%: only 'confirm' is documented in the schema, and the description merely restates 'Requires confirm=true.' The 'name' parameter is undocumented in both schema and description, and it is unclear whether it is a profile name or a directory path. The description does not compensate for the coverage gap.

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

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

States a specific verb and resource: 'Delete a profile directory.' An agent can tell this apart from sibling profile tools (create, list) by the destructive verb. It does not explicitly name alternatives, but the operation is unambiguous.

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

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

'Requires confirm=true' gives a clear precondition for invocation, and 'the active session is unaffected' implies when the impact applies. However, there is no guidance on when to choose this over create/list or any exclusion 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?

No annotations are provided, so the description carries the full burden. 'List' implies a read-only, non-destructive operation and it usefully discloses the on-disk location ~/.cloak-browser-mcp/profiles/, but it says nothing about the return shape, ordering, or behavior when the directory is empty or missing.

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

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

A single sentence with the action front-loaded and zero filler; every word earns its place.

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

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

For a trivial zero-parameter listing tool with no output schema, stating what is listed and where it lives is nearly sufficient. The only gap is that the returned representation (names vs. full paths, ordering) is 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?

The tool takes zero parameters, so the baseline is 4 and there is no parameter semantics for the description to compensate for.

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

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

States a specific verb (list) and resource (persistent profile directories) with an explicit storage location. It is clearly distinguishable from siblings cloak_persistent_profile_create/delete by implication, though it does not name them or explicitly frame itself as the read-only counterpart.

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

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

No when-to-use condition, no prerequisites, and no mention of alternatives such as create/delete. The agent must infer that this is the way to enumerate existing profiles before creating or deleting one.

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 present, the description carries the full behavioral burden, and it does add useful context: the URL loads in an ephemeral background tab, implying an isolated, non-disruptive read. However it omits key traits such as whether the tab is torn down, whether page scripts execute, or whether any state is mutated, which matters for a tool that navigates.

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

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

A single sentence that front-loads the action ('Open the target URL in an ephemeral background tab') and then enumerates the captured outputs. No filler or restatement of the name.

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, so the description must describe return values, and it does so thoroughly by listing status, TLS details, and both header sets. What is missing is the ephemeral tab's lifecycle and whether the operation has any side effects, but for a single-parameter read this is close to complete.

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

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

Schema coverage is 100% for the single url parameter and the schema already says 'connection signals (TLS, headers) we capture'. The description complements this by naming the specific request headers inspected (Accept-Language, User-Agent, Sec-CH-UA-*), adding 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 states a specific verb (open) plus the resource (target URL) and enumerates exactly what is captured (status, TLS, response/request headers), so the action is unambiguous. It does not differentiate itself from adjacent cloak_* diagnostic siblings such as cloak_detection_test or cloak_stealth_audit, which an agent could plausibly confuse it with.

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 statement of when to reach for this tool versus the sibling diagnostics (cloak_detection_test, cloak_stealth_audit) that also open a page and gather signals. Usage is only implied by the phrase 'capture per-request connection signals', leaving selection to inference.

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

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

With no annotations, the description carries the full burden and does disclose a genuine side effect beyond the schema: certain fields force context recreation and current pages are reopened on the same URL. This is exactly the kind of destructive/reloading consequence an agent needs. It stops short of stating which fields are cheap to change vs. expensive, beyond the parenthetical hint '(seed, GPU, screen)'.

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

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

Two tight sentences, purpose front-loaded, then the costly caveat. No filler and nothing duplicated. Slightly under-specified rather than verbose, but structurally sound.

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 11-parameter mutation tool with no annotations and no output schema, the description covers the single most important behavioral risk (context recreation) but leaves parameter semantics almost entirely undocumented against an 18% schema coverage. The description is complete on behavior, incomplete on inputs.

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 18% across 11 parameters, so the description must compensate and largely does not. The parenthetical '(seed, GPU, screen)' groups three of the eleven parameters but adds no meaning to them or to platform, deviceMemoryGB, storageQuotaMB, hardwareConcurrency, or uaBrandVersion. Accepted formats and valid ranges remain unexplained.

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?

Specific verb + resource: 'Apply a fingerprint profile to the active context.' This is clearly distinct from sibling cloak_set_timezone, cloak_set_locale and cloak_set_geolocation, though the description never names those siblings to reinforce the distinction. An agent can tell what it 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?

No when-to-use guidance, no exclusions, no alternatives named (e.g. cloak_detection_test to verify the result, or persistent profiles for durable fingerprints). The phrase 'active context' is the only contextual cue and it is not elaborated. The agent must infer the whole usage model.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the target surface (navigator.geolocation) but says nothing about persistence, whether the setting survives navigation, permission requirements, or interaction with the proxy. For an unannotated mutation tool this is a significant gap.

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

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

Two compact sentences, front-loaded with the primary effect followed by the proxy shortcut. Efficient, though the second sentence duplicates schema content.

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

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

A mutation tool with zero annotations, no output schema, and 3 of 4 parameters undocumented. The description should explain persistence and proxy interaction but does not, leaving the agent under-informed.

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

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

Schema coverage is only 25% (just fromProxyIp). The description restates the fromProxyIp semantics already present in the schema and adds no meaning for latitude, longitude, or accuracy. It does not compensate for the low 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?

States a specific verb+resource ('Set the geolocation reported by navigator.geolocation'), making the effect precise. It does not, however, explicitly differentiate itself from sibling setters like cloak_set_timezone, cloak_set_locale, or cloak_set_fingerprint.

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 one conditional hint (pass fromProxyIp=true to auto-resolve from proxy exit IP), which is implied usage rather than explicit when-to-use/when-not. No guidance on when to prefer explicit lat/long versus proxy-derived geolocation.

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 full disclosure burden. It usefully goes beyond a generic 'set locale' by naming the two surfaces affected (the JS navigator property and the HTTP Accept-Language header), which tells the agent the change is observable both in-page and on the wire. However, it says nothing about persistence, reversibility, whether already-loaded pages are affected, or any permission requirements.

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

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

A single sentence with the verb and affected surfaces front-loaded and zero filler. Nothing is redundant or buried.

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 one-parameter setter with no annotations and no output schema, the definition is thin: it omits the input format, the lifetime/scope of the override, and any interaction with already-rendered content. The core purpose is conveyed, but not enough for confident invocation.

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

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

Schema description coverage is 0% for the single 'locale' parameter, so the description must compensate and it does not. It never states the expected format (e.g., BCP-47 like 'en-US'), whether it accepts language-only tags, or any example value, leaving the agent to guess at valid input.

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 ('Override') and the exact resources affected ('navigator.language and Accept-Language'), so an agent knows precisely what the tool changes. It does not name or contrast with siblings like cloak_set_timezone or cloak_set_geolocation, but the resource is distinct enough to be told 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?

'for the active context' implies the scope of application but gives no explicit when-to-use, when-not-to-use, or prerequisite guidance. Usage is inferable from the verb/resource rather than stated, which is only minimally adequate.

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 it does disclose the critical side effect: the BrowserContext is recreated, so state survives only if --profile-dir was used, otherwise cookies are lost. That is exactly the kind of destructive consequence an agent needs. It omits proxy URL format/validation and return behavior, but the main behavioral trait is covered.

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

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

Two tight sentences with the action front-loaded and the side effect following immediately. Every clause earns its place; nothing is padded.

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 one-parameter mutation tool with no annotations and no output schema, the description covers the essential behavioral consequence and the state-preservation condition. It could say more about proxy URL expectations, but nothing critical for correct invocation 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 single 'proxy' parameter is already documented as a URL string with the context-recreation note. The description only restates the mid-session recreation effect, adding no syntax, format, or validation 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 ('Replace') and resource ('the current proxy'), and is immediately distinguishable from sibling setters like cloak_set_fingerprint or cloak_set_timezone. An agent can tell exactly what this tool mutates.

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

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

The description implies this is the tool to call to change the active proxy, but gives no explicit when-to-use guidance, no prerequisites (e.g. whether a proxy must already exist, whether it should be called before navigation), and no alternatives to weigh. Usage is implied by the verb rather than stated.

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

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

With no annotations, the description carries full behavioral burden. It does disclose a useful trait – the override is live via CDP and requires no relaunch – but omits whether it persists, whether it resets on navigation, and what happens to the previous timezone.

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 tight sentence with no waste, and the key scoping detail ('active context') is front-loaded before the mechanism note.

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 one-parameter setter with no annotations and no output schema, the description conveys scope and mechanism but leaves meaningful gaps: the timezone value format and the override's persistence/lifetime.

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 single parameter is a bare string. The description adds no semantics about the accepted timezone format (e.g., IANA identifier like 'America/New_York'), so an agent must guess the expected 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?

States a specific verb and resource ('Live-override the timezone for the active context'), making clear it sets the timezone. It implicitly distinguishes itself from the cloak_set_locale/geolocation/proxy siblings by naming the timezone, though it never explicitly differentiates them.

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

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

The phrase '(no relaunch)' implies the usage condition: change the timezone on a running context without restarting. However, there is no explicit when-to-use guidance, no contrast with the other cloak_set_* overrides, and no mention of prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the exact set of values returned (webdriver flag, plugin count, WebGL vendor/renderer, canvas hash, etc.), which is genuine behavioral content, but it says nothing about whether the operation is read-only, what session/page state it requires, or whether it mutates anything.

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

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

Two tight sentences, with the purpose front-loaded before the field enumeration. The long list of reported signals is dense but each item is informative rather than filler, so it stays efficient.

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

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

There is no output schema, so the description must explain the return surface, and it does so in detail. With zero parameters and no annotations, the only remaining gap is unstated preconditions (active page/session, read-only nature), which keeps it just under a 5.

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

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

The tool takes zero parameters, so there is no parameter semantics to document and the baseline is 4. Nothing in the description misrepresents or omits a needed argument.

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

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

States a specific action and subject ("Programmatic stealth audit") and then enumerates exactly which signals are reported, so the agent knows precisely what the tool surfaces. It is not distinguished from the sibling cloak_detection_test, which appears to overlap in intent, so it falls 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?

The word "audit" implies a diagnostic use case, but the description never states when to reach for this tool versus cloak_detection_test or the cloak_set_* tools. Usage is only inferable from the purpose, with no explicit alternatives or exclusions.

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