Mithwire MCP

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

With no annotations, the description carries the full behavioral burden, yet it only restates the navigation action. It says nothing about what happens at the start of history (no-op vs error), whether navigation blocks or waits for load, or how wait_seconds affects timing.

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. Efficiency is good, though the brevity is partly under-specification rather than disciplined pruning.

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

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

An output schema exists, so return values need not be described, but with no annotations and no parameter documentation the definition leaves key behavior (history exhaustion, waiting semantics) undefined for an agent to call it 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 0%, so the description must compensate, and it does not: session_id and wait_seconds (including its default) are unexplained. The only implicit signal is that the tool is session-scoped.

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 ('Navigate one step back in browser history'), which clearly separates it from browser_navigate and browser_forward. It does not explicitly name the sibling alternative, 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?

No guidance on when to use this versus browser_navigate, browser_forward, or browser_reload, and no mention of prerequisites such as an active session or existing history. The agent must infer usage 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, yet it only restates the name. It does not disclose what happens when zero or many elements match, whether the page navigates after the click, whether the element is scrolled into view, 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?

A single front-loaded sentence with no filler or redundancy. It is economically written, though its brevity reflects under-specification rather than disciplined 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 browser-automation click with 3 params, no annotations, and 0% schema coverage, one sentence is far too thin. The presence of an output schema means return values need not be explained, but the missing match-failure, waiting, and post-click behavior leave the agent under-informed.

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

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

Schema description coverage is 0% for 3 parameters. The description alludes to 'selector' and 'first matching' but says nothing about the selector syntax, the required session_id, or the wait_seconds default of 1.2, so it fails to compensate for the documented-coverage gap.

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

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

The description states a specific verb and target ('Click the first matching selector'), so the core action is clear. However it is extremely terse and does not distinguish browser_click from close siblings such as browser_mouse_click (coordinate-based) or browser_type, leaving the agent to infer the selector-based distinction from the name alone.

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

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

There is no when-to-use or when-not-to-use guidance, and no mention of alternatives like browser_mouse_click or browser_press_hold. The agent gets no signal about which clicking tool to pick or what preconditions (e.g. element present, session active) apply.

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 behavioral burden, and it discloses almost nothing. It does not say whether messages accumulate across navigation, what the default limit of 120 means for truncation, that the session must already be capturing, or that reading can have a side effect when clear is set — a meaningful omission for a tool adjacent to a destructive clear flag.

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 — the purpose is stated immediately. It is efficiently written, though the brevity is partly under-specification rather than disciplined 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?

An output schema exists, so return-value explanation is legitimately out of scope, but for a tool with an undocumented clear flag, a truncated-limit parameter, and no annotations, the description is too thin. An agent lacks what it needs to use the tool safely or predict its 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% across three parameters, so the description must compensate and does not. The non-obvious semantics of clear (does it wipe the buffer after returning?) and limit (default 120 suggests truncation) are left entirely 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 ("Read") and resource ("captured in-page console messages"), so an agent knows exactly what it retrieves. It does not, however, distinguish itself from adjacent read tools like browser_network_requests or browser_snapshot, leaving sibling routing to inference.

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 prerequisite (e.g. whether capture must already be running in the session), and no mention of alternatives for inspecting page errors versus network or DOM data. The agent gets a resource description but no selection logic.

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 discloses the scope ('all or by domain') but omits that this is a destructive, irreversible action, whether it affects active sessions, or what permissions/session context are 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. It is appropriately terse for a simple operation, though the extreme brevity leaves other dimensions underspecified.

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

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

An output schema exists, so return values need not be explained. However, for a destructive cookie-clearing tool with no annotations and 0% schema coverage, the description fails to cover the required session_id, irreversible effects, or when to choose it over sibling tools.

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 implies the optional domain parameter and that omitting it clears all cookies, but it never explains the required session_id parameter or adds format/constraint details.

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

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

The description states a specific verb and resource ('Clear cookies') and clarifies scope with '(all or by domain)'. It is distinguishable from sibling tools like browser_cookies_get or browser_cookies_set, though it does not explicitly name alternatives.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as browser_cookies_save or browser_storage_clear. The parenthetical only describes the parameter choice, not contextual usage.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a safe read, but says nothing about whether the domain parameter narrows results, required permissions, or how the operation interacts with the session. An output schema exists, so return format need not be described, but the behavioral profile is thin.

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 and the scope stated up front. It is efficient, though its brevity is partly a symptom of 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?

Output structure is covered by the output schema, but with three parameters at 0% schema description coverage and no annotations, the description leaves too much unstated: no domain filtering meaning, no session semantics, no behavioral notes. For a tool whose structured fields say almost nothing, this is inadequate.

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 schema documents no meaning for session_id, domain, or timeout_seconds. The description mentions no parameters at all, and its phrase 'all cookies' actively obscures the fact that domain can filter the result set, leaving an agent unable to infer parameter behavior.

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

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

States a specific verb (Get), resource (cookies), and scope (visible to current browser context), so an agent can tell it reads rather than writes cookies. It does not explicitly differentiate itself from siblings like browser_cookies_save or browser_cookies_clear, but the read-vs-mutate distinction is inferable from the name and wording.

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 context, no prerequisites, and no mention of alternatives such as browser_cookies_save for persistence or browser_storage_get for other storage. The scope phrase 'current browser context' is informative but is not usage guidance.

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

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

No annotations are provided, so the description carries the full burden and discloses nothing beyond the one-line purpose. It doesn't say whether the write overwrites an existing file, what permissions/auth the session needs, whether the cookie set is scoped to the current page or the whole browser context, or how timeouts and fallback behave. For a disk-writing tool 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, which is efficient and easy to scan. It is arguably under-specified rather than wasteful, but as a structural matter there is nothing to trim.

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

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

The presence of an output schema means return values needn't be described, but a six-parameter mutation tool with no annotations and 0% schema coverage needs more than one sentence. Key behavioral context (file overwrite semantics, cookie scoping, fallback behavior) is absent.

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% across six parameters, and the description only loosely gestures at output_path ('to a JSON file'). Nothing explains domain scoping, wrap_object, timeout_seconds, or allow_document_cookie_fallback, so the agent is left guessing at the meaning and defaults of most inputs.

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 ('Save current cookies') plus an output format ('to a JSON file'), which is enough to distinguish it from browser_cookies_get (retrieve) and browser_cookies_set (inject). It stops short of naming a sibling explicitly, so it stays at 4 rather than 5.

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

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

No when-to-use guidance, no prerequisites, and no routing to alternatives such as browser_cookies_get or browser_cookies_clear. The agent must infer that this is the persistence counterpart to cookies_get purely from the tool 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?

No annotations are provided, so the description carries the full behavioral burden, yet it only says cookies go into the current context. It omits whether existing cookies are overwritten or merged, whether the write is ephemeral or persisted, what permissions or an active session are required, and any error behavior for invalid domains.

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?

It is a single front-loaded sentence with no filler, which is structurally clean, but the brevity stems from under-specification rather than disciplined editing. Space freed by the short sentence is not used to clarify any parameter or behavior.

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

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

An output schema exists so return values need not be explained, but this is a mutation tool with no annotations and zero parameter documentation. For a tool whose correctness depends on cookie object shape and session scoping, the description leaves too much unstated.

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

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

Schema description coverage is 0% across three parameters. The description names "cookies" only implicitly, and the shape of each cookie object (name/value/domain/path/expiry) and the purpose of fallback_domain are entirely undocumented in both schema and description, so callers cannot construct a correct 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 concrete verb and resource ("Set cookies") plus the target scope ("current browser context"), so an agent knows this writes cookies into the live session. It does not, however, distinguish itself from siblings like browser_cookies_save or browser_storage_set, which a reader must infer from the names alone.

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

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

The description offers no when-to-use guidance, no prerequisites, and no comparison to browser_cookies_get, browser_cookies_save, or browser_cookies_clear. The agent must guess whether this is the right tool versus sibling cookies tools.

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

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

With no annotations, the description carries the full behavioral burden but says almost nothing. It never discloses that the 'clear' parameter mutates/destroys captured data, whether results are paginated, how they are ordered, or what 'captured' requires. A mutation-capable flag is hidden entirely.

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, which is structurally clean. It is arguably too terse for a 3-parameter tool, but there is no 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?

With no annotations, no parameter descriptions, and a destructive-capable 'clear' flag, the definition is far too thin. The output schema covers return values, but the input semantics and safety profile are entirely absent.

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 adds nothing about the three parameters. The critical 'clear' (destructive) and 'limit' (pagination) semantics are undocumented anywhere, leaving the agent to guess their behavior.

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

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

States a specific verb and resource: 'Read captured download metadata'. An agent knows it retrieves download records rather than performing an action. However, it offers no differentiation from the many other browser_* read tools (console_messages, network_requests, cookies_get) that follow the same pattern.

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 mention of prerequisites (e.g. that a session must be active), and no reference to alternatives. The agent must infer usage entirely from the name and schema.

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: it does not state whether the script runs in page context, whether it is sandboxed or blocked by CSP, whether async/promises are awaited, or how errors surface. For an arbitrary-code-execution tool this is a significant transparency gap.

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

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

A single short sentence with no wasted words and the core purpose front-loaded. It is efficient, though bordering on under-specification rather than genuine conciseness.

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

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

An output schema exists, so return values need not be described, but with zero annotations and zero schema coverage the definition is incomplete for a tool that executes arbitrary code: execution context, sandboxing, async handling, and error behavior are all unstated.

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

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

Schema description coverage is 0% for two required parameters, and the description adds no meaning beyond the names. It does not explain the expected form of 'script' (expression vs function body, return semantics) or what 'session_id' refers to.

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 ('Evaluate') and resource ('JavaScript in current page'), which is clear enough for an agent to distinguish it from siblings like browser_click or browser_html. However, it does not differentiate itself from the related browser_wait_for_function or browser_query tools, 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?

There is no guidance on when to use this tool versus alternatives such as browser_query, browser_wait_for_function, or browser_console_messages. No prerequisites, exclusions, or context conditions are stated.

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

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

With no annotations, the description carries the full behavioral burden and delivers little: it does not say what happens when there is no forward history (a common failure mode), that it mutates the active page state, or that it waits before returning. The only behavioral hint is the undocumented wait_seconds default.

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 padding and the key action stated first. It is efficient, though arguably terse enough to leave the gaps noted 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?

An output schema exists so return values need no explanation, but the description leaves the two undocumented parameters, the failure case (no forward history), and the wait behavior unaddressed. For a state-mutating navigation tool with zero annotation and zero schema-description coverage, 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 description coverage is 0% for two parameters, so the description must compensate and does not. Neither session_id nor wait_seconds is mentioned, and the meaningful wait-after-navigation behavior implied by wait_seconds (default 1.2s) is left entirely 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?

The description gives a specific verb and resource — 'Navigate one step forward in browser history' — which clearly separates it from browser_navigate and browser_reload by name alone. It stops short of explicitly contrasting itself with the obvious sibling browser_back, so it is clear but not sibling-differentiating in the text.

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 mention of the alternative (browser_back) or of the condition that makes forward navigation possible (having previously gone back). The agent must infer all of this from the tool 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?

No annotations are provided, so the description carries the full behavioral burden. It hints at one-shot scoping via 'next' but says nothing about the default handling if this is never called, whether the call is blocking, or what happens to the dialog's return value. Substantial behavioral gaps remain.

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 filler, and the scope constraint ('next') is front-loaded. It is not bloated, but it is under-specified rather than genuinely concise for a four-parameter configuration 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?

An output schema exists, so return values need not be explained. But with no annotations, 0% parameter documentation, and an ambiguous 'handled', the agent lacks what it needs to invoke this correctly — notably how to choose between accepting and dismissing.

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 four parameters (once, accept, session_id, prompt_text), and the description mentions none of them. The meaning of 'accept' vs 'once' vs 'prompt_text' — the entire point of the tool — is left completely undocumented.

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

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

The description names a specific resource (the next JavaScript dialog) and an action (set how it should be handled), so the agent knows this is a dialog-policy tool and it is unique among the siblings. However, 'handled' is vague — it never says accept/dismiss/prompt-text, which is the actual semantic content of the 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?

There is no when-to-use guidance: it does not say whether this must be called before a dialog appears, what happens if a dialog is already blocking, or how it relates to browser_click/browser_evaluate which trigger dialogs. The word 'next' implies one-shot scope but nothing more.

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 hints at truncation ("optionally truncated") but never says whether the default cap applies, how truncation is signaled, or that a live session is required. For a read tool with zero annotation coverage these are real gaps.

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

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

A single front-loaded sentence with no filler, which is proportionate to the amount of information actually conveyed. It is terse rather than padded, though that terseness is what drives the gaps above.

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

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

An output schema exists, so return values need not be explained, but the definition still omits the session prerequisite, the truncation contract, and any routing versus sibling content-retrieval tools. For a tool with 0% parameter documentation and no annotations, it 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 description coverage is 0%, so the description must compensate and largely doesn't. It vaguely alludes to truncation, mapping loosely to max_chars, but never names the parameter, explains its units/default, or describes what session_id selects.

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 (Return) plus resource (current page HTML), which is enough for an agent to know the operation. However, it does nothing to distinguish itself from close siblings like browser_snapshot, browser_query, or browser_evaluate, all of which also produce page content in different forms.

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 and no alternatives named. With 60+ siblings, several of which surface page content, the agent gets no help deciding between raw HTML, a snapshot, or an evaluate call.

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 delivers meaningful mechanism detail: it dispatches Input.dispatchMouseEvent through the browser's input pipeline and produces isTrusted events (material for anti-bot behavior), versus JS el.click(). It stops short of covering failure modes, whether the target must be in view, or timing behavior, which keeps it off a 5.

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

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

Three sentences, front-loaded with what the tool is, then the contrast with the sibling, then the usage trigger. No sentence is redundant and nothing is 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?

An output schema exists, so return values need not be explained. Purpose, alternative, and usage are complete; the only gap is the undocumented button/wait_seconds parameters, which is minor for a click tool.

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

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

Schema coverage is 0% across 5 parameters, so the description must compensate. It adds real meaning for x/y ('viewport pixel position'), but says nothing about button (default left) or wait_seconds (default 1.2), leaving two parameters undocumented in both places.

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 ('coordinate click at viewport pixel position (x, y)') and immediately distinguishes itself from the sibling browser_click by mechanism. An agent can tell the two apart without opening either schema.

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

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

Explicitly names the alternative (browser_click) and the condition selecting this one: 'Use when you need to click by coordinates — e.g. inside iframes or at positions obtained from screenshots/evaluation.' Both when and the concrete scenarios are given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that movement is implemented via intermediate mouseMoved CDP events and is useful for trails or hover, but it omits session/auth requirements, side effects, and how the steps parameter affects behavior.

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

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

The description is only two sentences, front-loads the core action, and then adds intended use cases. There is no redundant or wasted language.

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

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

An output schema exists, so return values do not need description. For a low-risk mouse-move tool, the purpose and mechanism are adequately covered, but without annotations and with 0% schema coverage, the missing steps semantics and session context leave notable gaps.

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

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

Schema description coverage is 0% across four parameters. The description clarifies x and y as viewport pixel coordinates, which adds useful meaning, but it entirely omits the steps parameter and session_id, leaving important invocation details undocumented.

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

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

The description states a specific verb and resource: moving the mouse cursor to viewport pixel coordinates via intermediate CDP mouseMoved events. It is clear what the tool does, but it does not explicitly differentiate itself from sibling tools like browser_mouse_click or browser_click.

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 implied contexts, saying it is useful for creating cursor movement trails before a click or for hover interactions. However, it does not name alternatives, state when not to use it, or explain prerequisites in any explicit way.

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 nothing: it doesn't say whether navigation blocks until load, what counts as success/failure, how the defaulted wait_seconds behaves, or whether the URL must be absolute. This is a bare restatement of the tool name.

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 padding, which is structurally clean. However, at this length it reads as under-specification rather than deliberate conciseness, so it only earns a middle score.

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

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

An output schema exists, so return values need not be described. But for a foundational navigation tool with zero annotation coverage and zero parameter documentation, the definition is missing critical context: session requirements, load/wait semantics, and error 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 supplies no parameter meaning at all. It never explains that session_id identifies the target browser session or that wait_seconds is a post-navigation delay, leaving all three parameters undocumented.

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

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

States a specific verb and resource ('Navigate to a URL'), so an agent immediately knows this performs navigation. It does not distinguish itself from nearby siblings such as browser_back, browser_forward, browser_reload, or browser_url, which all operate on the same tab URL concept.

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 mention of prerequisites (an active session_id), and no routing to alternatives like browser_back/reload for history navigation. The agent must infer usage 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 discloses almost nothing. Most notably, the 'clear' parameter likely destroys captured data, but the description never warns about destructive behavior, nor does it state whether the result is a snapshot or a paginated tail, or any lifecycle prerequisite.

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 with no filler, which is fine, but its brevity comes from under-specification rather than discipline. Nothing is front-loaded because there is essentially nothing to front-load.

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

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

An output schema exists, so return-shape explanation is not required. But for a four-parameter tool with zero annotation coverage, the definition omits parameter meanings, the destructive nature of 'clear', and the capture lifecycle relationship to the sibling start/stop/status tools.

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 adds nothing: no explanation of 'limit' semantics, no warning that 'clear' purges the buffer, no clarification of what counts as a 'failure' for 'only_failures'. All four parameters are wholly undocumented in both places.

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 ('Read') and resource ('CDP-level network capture rows'), which is more than a tautology. However, it does not distinguish this from close siblings like browser_network_requests or browser_network_capture_status, leaving the agent to guess which reader to call.

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. It never says that a capture must presumably be started first (browser_network_capture_start), nor how it differs from browser_network_requests or browser_network_capture_status. The agent must infer the whole workflow from sibling names.

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

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

With no annotations, the description carries the full behavioral burden and discloses almost nothing. It does not mention that capture is bounded by max_entries (default 2000), whether starting a capture overwrites a prior one, whether capture continues until explicitly stopped, or any memory/performance implications of protocol-level recording.

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 fragmentary sentence with no waste, but at this length it is under-specified rather than concise — the brevity comes at the cost of any usable detail for a five-parameter tool. Front-loading is fine; substance is missing.

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

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

An output schema exists so return values need not be described, but for a capture-start tool with five undocumented parameters, no annotations, and a four-tool capture family, the description omits everything an agent needs: prerequisites, filtering behavior, and the stop/read lifecycle.

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

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

Schema description coverage is 0% and the description mentions none of the five parameters. The meaning of url_regex (what syntax, does null mean capture-all), max_entries, include_headers, and include_post_data is left entirely 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?

States a specific verb ('Start') and resource ('CDP-level network capture'), and the 'CDP-level' qualifier hints at a lower-level capture than sibling browser_network_requests. However, it never explicitly contrasts itself with the closely-named siblings browser_network_capture_stop, browser_network_capture_get, or browser_network_capture_status.

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: it does not say whether an active session is required, whether capture must be paired with browser_network_capture_stop, or how it differs from reading browser_network_requests. The agent must infer the whole lifecycle from sibling names.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation via 'Get' but does not state that it is non-destructive, whether it requires an active capture, what the status reflects, or whether it blocks. For a no-annotation tool 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?

One short front-loaded sentence with no filler or repetition. It is efficient, though the brevity 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?

An output schema exists, so return values need not be explained. But with no annotations and no parameter documentation, the description should at least note the dependency on the capture lifecycle (start before status) to be complete for this multi-tool capture family.

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

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

Schema coverage is 0% and the single required session_id parameter has no description in either the schema or the tool description. The description adds no meaning about what session_id identifies or whether it must reference a live session.

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

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

States a specific verb (Get) and resource (CDP-level network capture status), which is more informative than the bare name. However, it does not distinguish this tool from the closely related siblings browser_network_capture_start/get/stop, so an agent cannot tell from the description alone when status is the right call.

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 mention of prerequisites (e.g., that a capture must be running first), and no reference to the start/get/stop siblings. The agent is left to infer the whole usage context 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?

No annotations are provided, so the description carries the full burden. It says only that capture stops; it does not disclose whether buffered data is discarded, whether the call is idempotent if no capture is running, what permissions or session state are required, or how it interacts with the existing 'clear' parameter.

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 waste, which is good, but at this level of brevity the terse text reads as under-specification rather than crispness for a tool with an undocumented parameter.

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

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

An output schema exists, so return values need not be described. However, for a capture-lifecycle mutation tool with zero annotation coverage and an unexplained 'clear' flag, the description omits the behavioral and parameter context 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 0% and there are 2 parameters, yet the description explains neither. In particular, the 'clear' boolean's effect (whether capture is stopped and buffered entries are wiped) is left entirely ambiguous, and no format or constraints are given for session_id.

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

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

The description states a specific verb and resource ('Stop CDP-level network capture'), and the name distinguishes it from sibling capture tools (start/get/status). The 'CDP-level' qualifier adds precision about the layer being captured, though it stops short of explicitly routing the agent to or from those siblings.

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

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

There is no guidance on when to call this versus alternatives, nor any mention that it pairs with browser_network_capture_start. An agent gets no indication of prerequisites, expected ordering, or what state the session must be in.

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, yet it only tells the agent this is a read operation. It does not disclose that the required session_id selects a session, that limit bounds results, or that the clear parameter may clear captured data—a potentially important side effect.

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, but it is under-specified for a tool with three parameters and no schema descriptions. Brevity here is not necessarily appropriate given the missing operational context.

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

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

Although an output schema exists so return values need not be explained, the description omits all parameter context and any behavioral nuance around clearing or session selection. For a tool with a required session_id and a clear side-effect parameter, the definition is incomplete.

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

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

Schema description coverage is 0% across all three parameters (session_id, limit, clear), and the description adds no parameter meaning whatsoever. The agent gets no explanation of the required session_id, the default limit of 120, or what clear actually does.

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

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

The description states a specific verb (Read) and resource (captured fetch/xhr request metadata), so the purpose is clear. However, it does not distinguish this tool from closely named siblings like browser_network_capture_get or browser_network_capture_status, which likely overlap in reading captured network data.

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

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

There is no guidance on when to use this tool versus the many network-capture siblings, nor any conditions or prerequisites. The sentence only describes what it reads, leaving the agent to infer usage from context.

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

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

No annotations are provided, so the description carries the full burden, and it delivers non-obvious behavioral detail: the exact event sequence (mousePressed, mouseMoved jitter, mouseReleased) that an agent could not infer. It omits what wait_seconds controls and whether the hold can be interrupted, so not a 5.

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

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

Three sentences, front-loaded with the action, then the mechanism, then the use case. No filler; every clause contributes.

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?

Output schema exists so return values need not be explained, and the description adequately covers action, mechanism, and purpose for a browser interaction tool. The main gap is the unexplained wait_seconds parameter, which is a moderate rather than critical omission.

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 there are 5 parameters. The description implies x, y (viewport coordinates) and duration, but never names duration_ms, and wait_seconds is completely undocumented in both schema and description. Only a fraction of the parameters are compensated 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 precise verb+resource: 'Sustained mouse press at viewport pixel (x, y) for a given duration.' The word 'sustained' and 'press-and-hold' clearly distinguish it from the click/mouse_click siblings in the list.

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

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

Gives explicit usage contexts ('press-and-hold verification challenges or long-press interactions'), which tells the agent when this is the right tool versus a normal click. It stops short of naming browser_click/browser_mouse_click as alternatives or stating when not to use it.

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

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

No annotations are provided, so the description carries the full behavioral burden and does not meet it. It doesn't say whether the query waits for elements, what happens when the selector matches nothing, whether returned handles are reusable by browser_click/browser_type, or whether it is a safe 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?

A single front-loaded sentence with no waste, so it is structurally fine. However it is minimal to the point of under-specification rather than genuinely concise.

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

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

An output schema exists so return format needn't be explained, but for a three-parameter, annotation-free browser tool the description leaves key gaps: pagination/limit behavior, session binding, and how results relate to other browser_* interaction tools.

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 only implies the selector parameter. Neither 'limit' (default 40) nor 'session_id' receives any explanation, and the return-handle semantics tied to the selector are unstated.

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 ('Query DOM elements') plus the input mechanism ('by CSS selector'), which is clear enough to act on. It does not distinguish itself from near-neighbors like browser_snapshot, browser_html, or browser_wait_for_selector, 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 when-to-use guidance, no conditions, and no mention of alternatives among the many overlapping DOM-inspection siblings. An agent must guess whether this replaces browser_snapshot/browser_html or complements them.

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, and it discloses almost nothing: it does not say whether the call blocks until the page finishes loading, whether it affects other tabs, or how caching is handled. The phrase 'current page' is the only behavioral signal, telling the agent it acts on the active tab rather than an arbitrary URL.

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. It is efficiently sized, 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?

An output schema exists, so return values need not be described, but for a three-parameter tool with no annotations and no schema documentation the description is too thin. An agent cannot tell from it whether reload waits for load completion or what wait_seconds and ignore_cache actually do.

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 adds nothing about any of the three parameters. The semantics of ignore_cache and wait_seconds (which presumably controls how long to wait after reloading) are left entirely unexplained in both places.

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 (Reload) and resource (the current page), which is unambiguous on its own. It does not distinguish itself from adjacent navigation siblings such as browser_navigate, browser_back, or browser_forward, 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?

There is no guidance on when to reload versus re-navigating, and no mention of prerequisites such as needing an active session or a page already loaded. Usage is only implied by the verb.

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 disclosure burden. It says nothing about the wait_seconds settle behavior after scrolling, what happens if to_top and to_bottom are both set, whether scrolling is smooth or instant, or whether the call blocks until the page stabilizes.

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 with the primary verb front-loaded and the mode list immediately following. It is efficient, though the brevity tips into under-specification rather than pure economy.

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

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

An output schema exists so return values need not be explained, but for a six-parameter tool with zero schema description coverage and no annotations, the description is far too thin. An agent cannot determine precedence among the four scroll modes or the role of delta_y versus to_bottom from this text.

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% across six parameters, and the description only obliquely accounts for three of them (to_top, to_bottom, selector). It adds no meaning for delta_y, wait_seconds, or the required session_id, and does not explain interaction or precedence between the mode flags.

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

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

States a specific verb (scroll) and resource (page) and enumerates the modes: to top, to bottom, or to selector. No sibling tool performs scrolling, so sibling differentiation is not really needed here, but the phrasing is terse and never names the session context it operates on.

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 guidance, no prerequisites, and no indication of how to choose between to_top, to_bottom, delta_y, and selector modes. The agent must infer all routing logic from the schema defaults.

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 mentions attaching local files but does not disclose side effects such as triggering change events, whether files are uploaded, required session context, selector constraints, or the role of wait_seconds.

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 and easy to scan.

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

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

Given the tool has four parameters, three of them required, and no annotation or schema descriptions, the definition is incomplete. The presence of an output schema covers return values, but critical invocation details such as the required session_id and wait_seconds behavior are absent.

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

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

Schema description coverage is 0%, so the description must compensate but does so only vaguely. 'File input selector' hints at the selector parameter and 'local files' hints at file_paths, but session_id and wait_seconds are completely undocumented in both schema and description.

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

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

The description states a specific verb and resource: 'Attach local files to a file input selector.' This clearly distinguishes the action from siblings like browser_type or browser_click, though it does not explicitly name or contrast 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 when-to-use guidance, prerequisites, or alternatives. The only implied context is that the tool is for attaching local files to a file input, but there is no explicit guidance on when this should be used instead of related browser actions.

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 doesn't disclose that the snapshot is truncated/capped (the 'limit' default of 40), whether it is a safe read with no page mutation, or what 'compact' means in terms of completeness or ordering.

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. It is efficient, though the brevity is partly a consequence of omitted detail 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?

An output schema exists, so return values need not be explained, but the description still leaves critical gaps: undocumented parameters at 0% coverage, no behavioral disclosure in the absence of annotations, and no routing against sibling page-inspection tools. For a tool in a crowded family, this is insufficient.

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

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

Schema description coverage is 0%, so the two parameters (session_id and limit) are undocumented in both schema and description. The word 'compact' hints that results are bounded, but the description never explains what 'limit' controls or that it defaults to 40, leaving the agent unable to tune the 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 ('Return') and a specific resource ('compact snapshot of interactive elements on the page'), so an agent knows this yields a listing of actionable page elements rather than raw HTML. However, it gives no differentiation from close siblings like browser_html, browser_query, or browser_take_screenshot, which also describe the same 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?

The description offers no when-to-use guidance, no prerequisites, and no mention of alternatives. With siblings such as browser_html and browser_query in the same family, an agent is left to guess which extraction tool is appropriate in a given situation.

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 mechanism (clicking the verification checkbox) but says nothing about failure behavior, what happens after retries are exhausted, or how it interacts with the max_retries/timeout parameters — significant gaps for a tool with an output schema and retry logic.

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 efficient, though its brevity contributes to the other gaps rather than being purely a virtue.

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

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

An output schema exists, so return values need not be explained, but the description omits parameter semantics and any behavioral detail on failure/retry handling. For a challenge-solving tool with retry and timeout knobs, this leaves the agent under-informed.

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

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

Schema description coverage is 0% and all three parameters (session_id, max_retries, timeout_seconds) are undocumented in the schema. The description adds no meaning for any of them, so it fails to compensate for the coverage gap.

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

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

States a specific verb+resource: 'Detect and solve a Cloudflare Turnstile challenge by clicking the verification checkbox.' This is unambiguous and clearly distinguishable from generic siblings like browser_click or browser_wait_for_selector, since it names a specific anti-bot challenge type.

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

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

The trigger scenario (a Cloudflare Turnstile challenge being present) is implied by the description, but there is no explicit when-to-use/when-not guidance or pointer to alternatives such as browser_click or browser_wait_for_selector. Usage must be inferred.

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. Clearing storage is a destructive, irreversible data-loss operation, yet the description says nothing about which origins are affected, whether the page reloads, whether the session must be active, or whether a session_id mismatch is an error. Only the bare action is conveyed.

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 with the action front-loaded — efficient, but the terseness is under-specification rather than genuine conciseness for a destructive mutation with two parameters.

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

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

An output schema exists, so return values need not be explained. For a destructive, unannotated, 0%-covered two-parameter tool, however, the definition omits scope, side effects, and parameter meaning — not enough for an agent to call it safely.

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 hints at the 'kind' concept ('local/session') but never explains the enum values, the default of 'both', or what the required session_id identifies. Both parameters are effectively 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 (clear) and resource (local/session storage), which distinguishes it from siblings like browser_storage_get, browser_storage_set, and browser_cookies_clear. It does not, however, clarify scope (current page origin vs. all origins), so the purpose is clear but not fully bounded.

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 adjacent alternatives (browser_cookies_clear for cookies, browser_storage_set for writes). The agent must infer that this is the correct tool purely 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 carries the full behavioral burden and discloses almost nothing: it doesn't say whether it acts on the current tab, whether it requires an active session, how it behaves when storage is empty, or that it's a read-only operation. Only the verb "Get" weakly implies read semantics.

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

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

A single short sentence with no filler and the action front-loaded. It is efficient, though the brevity tips into under-specification rather than crispness.

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

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

The output schema covers return shape and there are only two parameters, but with zero annotation coverage the description should explain the required session_id and the kind selector's semantics. For a session-scoped browser tool it leaves too much for the agent to infer.

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 and it largely doesn't. "local/session" hints at the `kind` enum but never explains the `both` default or the values `local`/`session`, and `session_id`, the only required parameter, is never mentioned at all.

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

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

The description names a specific verb ("Get") and resource ("local/session storage values"), which cleanly separates it from sibling writers like browser_storage_set and browser_storage_clear. It stops short of saying anything about the browser session it operates against, but the core action is unambiguous.

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

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

There is no guidance on when to reach for this versus alternatives such as browser_evaluate, which could also read storage, or browser_cookies_get for a related but different store. No prerequisites or exclusions are given.

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

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

No annotations are provided, so the description carries the full disclosure burden and largely fails it. It never says whether entries are merged with or overwrite existing keys, what clear_first does to existing storage, or whether this persists across navigation — all material for a mutation 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?

A single front-loaded sentence with no wasted words. It is efficient, though its brevity borders on under-specification rather than genuine conciseness.

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

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

An output schema exists, so return values need not be described. However, for a four-parameter mutation tool with zero annotation and zero schema-description coverage, the description omits the destructive/merge semantics and session requirements an agent needs to invoke it safely.

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

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

Schema description coverage is 0%, so the description must compensate. It only hints at 'key/value entries' and the local/session distinction, leaving clear_first — a potentially destructive flag — completely unexplained in prose, and giving no format or size guidance for the entries object.

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 ('Set') and resource ('local/session storage key/value entries'), which clearly separates it from siblings like browser_storage_get and browser_storage_clear. It does not explicitly name those siblings, so it lands at a clear-but-undifferentiated 4.

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 mention of prerequisites (e.g. an active session_id), and no routing to alternatives such as browser_storage_get for reads or browser_storage_clear for wipes. The agent must infer all of this 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. 'Close' implies an irreversible destructive mutation, but the description never says whether the close is permanent, what happens if both tab_id and index are supplied, how switch_to affects focus, or whether closing the final tab terminates the session. For a destructive tool with zero annotation coverage 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?

A single short sentence with no filler and the action front-loaded, which is structurally sound. However, the brevity reflects under-specification rather than disciplined conciseness.

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

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

An output schema exists, so return values need not be explained. But for a destructive 4-parameter tool with no annotations and no parameter documentation, the description omits the selection semantics, the switch_to behavior, and the side effects an agent must know before invoking it.

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

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

Schema description coverage is 0% across 4 parameters. The description names tab_id and index but does not explain that they are alternative selectors, nor does it mention switch_to (default 'last_active') or session_id at all, leaving half the parameters undocumented in both schema and description.

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

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

States a specific verb+resource ('Close a tab') and names the two identifiers it accepts, which lets an agent distinguish it from browser_tab_switch, browser_tab_new, and browser_tab_list. It stops short of stating scope (does it close the active tab? is a session teardown implied?), but the core action is unambiguous.

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

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

There is no when-to-use guidance, no note on what happens when closing the active or last remaining tab, and no pointer to sibling tools. The agent must infer everything from the tool 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?

No annotations are provided, so the description carries the full behavioral burden. 'Get' weakly implies a read-only, non-mutating call, but the description says nothing about whether a session must be attached to a live browser, what happens if no tab is active, or whether the read is side-effect free. An output schema exists, so return format need not be restated, but the remaining gap is large for a tool with zero annotation coverage.

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 with no filler and no burying of the key concept. It is efficient, though the terseness is partly 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?

The tool is simple and has an output schema covering return values, so the description need not explain results. But with no annotations, an undocumented required parameter, and no routing guidance among many tab-related siblings, an agent is left guessing about preconditions and scope.

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 required parameter session_id, so the schema contributes nothing. The description does not mention session_id at all — it neither states that it identifies the browser session nor what form it takes — leaving the parameter undocumented in both structured and unstructured data.

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 verb ('Get') and a resource ('active tab summary'), so the basic action is inferable. However, 'summary' is undefined — it is unclear whether it returns a title/URL pair, DOM state, or something else — and nothing distinguishes it from the sibling browser_tab_list or browser_snapshot. Purpose is recognizable but vague on scope.

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 use this tool versus alternatives such as browser_tab_list (all tabs) or browser_snapshot (page content), nor any precondition or context requirement. The only implied usage is 'you want the current tab', which the name already conveys.

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. "List" implicitly signals a read-only, non-destructive operation and the presence of the active tab among the results is disclosed, but there is no statement about ordering, pagination, or that this never mutates browser state. The implicit read-only semantics keep it at a minimum-viable 3 rather than lower.

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 sentence, front-loaded with the verb and resource, no boilerplate or repetition. Every word earns its place.

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

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

An output schema exists, so return values need not be explained here, and the operation itself is simple. What is missing is any routing versus the closely related browser_tab_current, browser_tab_switch, and browser_tab_new siblings, plus any meaning for the undocumented session_id.

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 session_id parameter has no description in either the schema or the tool description. The description does not compensate at all, leaving the agent to guess whether session_id refers to a browser session key or something else; only the sibling-tool context makes it inferable.

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 ("List open tabs") plus the scope of what is returned ("and the active tab"), so the agent knows exactly what this tool produces. However it never distinguishes itself from the very similar sibling browser_tab_current, which also surfaces the active tab, so there is no explicit sibling differentiation.

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

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

There is no when-to-use, when-not-to-use, or alternative guidance. The agent must infer from the name alone that this is the enumeration counterpart to browser_tab_current / browser_tab_switch, and nothing tells it when listing all tabs is preferable to reading the current tab.

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 but discloses almost nothing: it doesn't say whether existing tabs are preserved, whether the session must be active, what happens if url is omitted (schema default about:blank), or how wait_seconds affects the call. For a state-mutating tab-creation 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?

A single short sentence with no filler, front-loaded with the main action. It is concise, but that brevity is partly the result of under-specification rather than tight 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?

An output schema exists, so return values need not be described, but everything else is missing: parameter meanings, interaction with sibling tab tools, and side effects. For a 4-parameter tool with zero schema coverage and no annotations, the definition is too thin.

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% across 4 parameters, so the description must compensate. It only gestures at 'switch' behavior; url, wait_seconds, and the required session_id are entirely unexplained, leaving the agent to infer semantics from bare titles.

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 ('Open a new tab'), so the agent knows exactly what happens. However, it does not distinguish itself from the sibling browser_tab_switch, which overlaps with the 'switch to it' behavior mentioned here.

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 open a new tab versus reusing or switching tabs, and no mention of the browser_tab_switch/browser_tab_list siblings. The only hint is the word 'optionally', which is not actionable guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the action. It omits side effects, error behavior when a tab doesn't exist, what wait_seconds does, and any permission or session 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 front-loaded sentence with zero filler; every word earns its place. It is arguably too terse given the tool's parameter surface, but that is a completeness issue rather than structural waste.

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

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

With no annotations, 0% schema description coverage, and four parameters, the description is not complete enough. An output schema exists so return values needn't be explained, but session_id, wait_seconds, and the tab_id/index relationship are all left undocumented.

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

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

Schema description coverage is 0%, so the description must compensate but only names two of four parameters (tab_id, index). It gives no format for tab_id, no index range, no mutual-exclusivity rule, and never mentions the required session_id or the wait_seconds 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?

States a specific verb ('Switch') and resource ('active tab') with the selection mechanism ('by tab_id or index'). Distinguishes itself from tab_new/tab_close, but does not explicitly differentiate from siblings like browser_tab_current or browser_tab_list.

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 or alternatives are given. It doesn't say which of tab_id/index to prefer, whether both can be supplied, or how it relates to browser_tab_current. Usage is only implied by the phrase 'by tab_id or index'.

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. 'To disk' usefully implies a filesystem write side effect, but it says nothing about full-page vs viewport capture, format implications, overwrite behavior of output_path, or whether the target session must be active.

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 waste, which is good, but at this length the brevity reads as under-specification rather than efficient concision for a four-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?

An output schema exists so return values need not be explained, but with no annotations, 0% schema coverage, and four parameters (two required), the description is far too thin for an agent to call this reliably without opening the schema.

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

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

Schema description coverage is 0% and there are four parameters, so the description must compensate but does not. It only vaguely gestures at output_path via 'to disk' and never mentions session_id, full_page, or the png/jpeg image_format enum.

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 ('Capture a screenshot') plus the destination ('to disk'), so an agent immediately knows what it does. It does not distinguish itself from near-neighbors like browser_snapshot or browser_html, but the noun 'screenshot' is unambiguous.

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

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

There is no when-to-use guidance, no prerequisites (e.g. an active session), and no mention of alternatives such as browser_snapshot for DOM capture. The agent is left to infer usage entirely 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?

No annotations are provided, so the description carries the full behavioral burden, yet it discloses only the basic action. It says nothing about what the clear/submit flags destroy or trigger, whether typing waits for the element, or how the wait_seconds default behaves.

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 waste, but its brevity comes from omission rather than efficiency. It is structurally fine yet under-specified for a tool with five optional/required parameters.

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

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

An output schema exists so return values need not be explained, but for a browser mutation tool with no annotations and 0% parameter documentation the description is far too thin. An agent cannot know how clear/submit interact with the typed text.

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% across 6 parameters, so the description must compensate, but it only implicitly covers 'text' and 'selector'. The meaning and effects of clear, submit, wait_seconds, and session_id are left completely 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?

The description gives a specific verb (Type) and resource (text into an input selector), which is enough to distinguish it from browser_click or browser_press_hold. It is clear but does not explicitly name any sibling or scoping condition, so it falls short of the 5 bar.

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 (e.g. an existing session_id), and no mention of alternatives such as browser_click or browser_evaluate for filling fields. The agent must infer usage 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 state that this is a read-only, side-effect-free operation, nor what happens if the session has no active page or the session_id is invalid. For a zero-annotation tool this is a meaningful gap, though the operation is inherently simple.

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 with zero filler, front-loading the action and the returned data. Nothing is padded or redundant.

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

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

An output schema exists, so the return values need not be explained, and the tool is conceptually simple. Still, the description omits the session_id contract and failure modes for a tool that cannot function without a valid session, leaving it only minimally viable.

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 single parameter session_id has 0% schema description coverage and the description adds no meaning about it — no format, no source, no statement that it must reference a live session. The one-sentence description provides no parameter context to compensate.

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: 'Get current URL and page title.' An agent immediately knows the retrieval target. However, it does not differentiate from the sibling browser_tab_current, which plausibly returns overlapping information, 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives. With sibling tools like browser_tab_current and browser_tab_list in the same family, the description should say when this tool is the right pick, and it says nothing.

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 conveys only that a blocking delay occurs and says nothing about blocking semantics, session requirements, or whether the wait is an unconditional sleep rather than a condition poll.

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 waste, which is structurally fine. However, it is under-specified rather than genuinely concise: one sentence is simply too little to disambiguate this tool from its wait-family siblings.

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

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

An output schema exists, so return values need not be explained. Everything else is missing, though: no annotations, 0% schema description coverage, an undocumented required session_id, and no routing against the conditional wait tools, making the definition inadequate for correct tool selection.

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

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

Schema description coverage is 0%, so the description must compensate. It only gestures at the 'seconds' parameter via 'a number of seconds' and omits the default (1.2), the unit/rounding behavior, and any mention of the required session_id, leaving both parameters effectively undocumented.

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

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

The verb 'Wait' plus the notion of a duration gives a minimally clear purpose, and the name implies a browser-context pause. But the description never distinguishes this fixed-duration sleep from the large sibling family of conditional waits (browser_wait_for_selector, browser_wait_for_url, browser_wait_for_text, browser_wait_for_function, browser_wait_for_network_idle), leaving the agent to guess which wait tool applies.

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

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

There is no guidance on when to use this tool versus the many browser_wait_for_* siblings, nor any stated prerequisite such as an active session. The agent must infer everything about selection from the tool name alone.

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

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

With no annotations, the description carries the full burden. It conveys only the core blocking-wait semantics and says nothing about what happens on timeout (error vs. false return), that polling occurs, or that it is a safe read operation — all of which are relevant for an agent deciding whether to block on this call.

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, but it is under-specified rather than efficient — there is no second sentence of useful context, which this four-parameter wait tool clearly needs.

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

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

With four parameters, zero schema coverage, no annotations, and multiple sibling wait tools, the definition is too thin. The output schema means return-value detail is not needed, but timeout behavior, polling, and selection versus alternatives are all 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 0% across four parameters, and the description compensates only by loosely implying the 'script' argument. Required session_id and the optional timeout_seconds and poll_interval_seconds (with their defaults) get no explanation of format, units, or effect on behavior.

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

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

States a specific verb and resource: waiting until a JavaScript expression is truthy. The 'JavaScript expression' scope implicitly separates it from the sibling wait tools (browser_wait_for_selector, browser_wait_for_url, browser_wait_for_text), though it never names them 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 guidance on when to prefer this over browser_wait_for_selector, browser_wait_for_text, browser_wait_for_network_idle, or plain browser_wait, despite five near-neighbor wait tools in the sibling list. The agent must infer the distinction purely from the tool 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?

No annotations are supplied, so the description carries the full disclosure burden, and it delivers almost nothing: it does not say whether the call blocks, what happens when timeout_seconds elapses (error vs. silent return), or whether idle means zero in-flight requests plus a quiet period. For a timing-sensitive wait 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?

A single front-loaded sentence with no filler, which is structurally clean, but for a tool with five parameters and no other documentation it is under-specified rather than genuinely concise.

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

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

An output schema exists, so return values needn't be described, but the definition still leaves timeout semantics, idle definition, and four of five parameters undocumented with no annotations to fall back on. Only the required session_id and the defaults make a minimal call safe.

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?

Five parameters with 0% schema description coverage, and the description explains none of them. Cryptic fields like idle_ms and max_inflight (default 0) are left entirely undefined, so an agent cannot reason about how to tune the wait window versus the timeout.

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') plus a precise resource ('in-page network activity is idle'), which is genuinely distinct from the other wait siblings (selector/url/text/function). It does not, however, explicitly contrast itself with browser_wait or the polling variants, so an agent must infer the difference from the name alone.

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

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

No statement of when to prefer this over browser_wait, browser_wait_for_function, or browser_network_capture_*. No prerequisite or sequencing advice (e.g. call after clicking a navigation trigger) 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 burden. It discloses only that the wait ends on appearance or timeout, but says nothing about what happens on timeout (error vs. falsy return), whether it polls or blocks, whether it is safe/non-destructive, or any session requirement. An output schema exists, so return-shape detail is not required, but the timeout semantics remain undisclosed.

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

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

A single short, front-loaded sentence with no filler. It is efficient rather than padded, though the extreme brevity is under-specification rather than a model of 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 three-parameter browser tool with zero schema descriptions, no annotations, and five closely related wait siblings, this description is not complete enough. The output schema covers return values, but timeout behavior, selector format, and sibling differentiation are all 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 0% and there are three parameters (selector, session_id, timeout_seconds) with no per-field descriptions. The description only alludes to the timeout concept and adds no meaning for selector syntax (CSS vs. XPath) or the required session_id, so it fails to compensate for the schema gap.

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

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

States a verb (wait) and a resource (selector), so an agent knows the operation, but the phrasing largely restates the tool name. It does not distinguish this from the many sibling wait tools (browser_wait, browser_wait_for_text, browser_wait_for_url, browser_wait_for_function, browser_wait_for_network_idle), so the reader must infer the difference from the name alone.

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

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

There is no guidance on when to choose this over browser_wait, browser_wait_for_text, or browser_wait_for_function, nor any prerequisite or sequencing note (e.g., run after navigation). Usage must be inferred entirely from the tool 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 it discloses almost nothing: it doesn't say whether the call blocks, what happens on timeout (error vs. false return), that it polls, or that the default timeout is 10s. 'Wait until' implies blocking, which is the only behavioral hint provided.

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. It is efficient, though the brevity edges into under-specification for a six-parameter tool with 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?

An output schema exists, so return values need not be explained, but for a 6-parameter polling/wait tool with 0% schema coverage and no annotations the description omits critical context: timeout semantics, failure behavior, and matching/case rules. An agent cannot call this correctly without guessing.

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% across 6 parameters, so the description must compensate and it does not. It alludes to only two parameters (text, selector) with no format or matching details, and never mentions case_sensitive, timeout_seconds, poll_interval_seconds, or session_id.

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

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

The description gives a specific verb (wait) and resource (text) plus a location qualifier (in a selector), so the core behavior is unambiguous. It does not, however, distinguish itself from the crowded wait family (browser_wait_for_selector, browser_wait_for_url, browser_wait_for_function, browser_wait_for_network_idle), so an agent must rely on the name alone to pick correctly.

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

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

There is no guidance on when to use this tool versus the four sibling wait tools, and no statement of preconditions (e.g. an active session, page loaded). The only usage signal is the tool name itself.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses almost nothing beyond the one-liner: it doesn't state that the call blocks/polls, what happens on timeout (return vs. throw), or that url_contains and url_regex are alternative match modes. For a long-running wait primitive 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?

One front-loaded sentence with zero filler, but it is under-specified rather than truly concise given the tool's complexity. The brevity is not excessive wording but excessive omission.

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

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

An output schema exists, so return values needn't be explained. However, with no annotations, 0% parameter coverage, and five parameters, the description leaves critical blocking/timeout/match-mode semantics undefined—not complete enough for an agent to call this reliably.

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% across 5 parameters. The phrase 'substring or regex match' loosely maps to url_contains and url_regex, but session_id, timeout_seconds, and poll_interval_seconds are given no meaning beyond their names, and the mutual-exclusivity/alternative behavior of the two matchers is unstated.

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 ('Wait for URL') with the acceptance criteria ('substring or regex match'), which distinguishes it from browser_wait_for_selector, browser_wait_for_text, and browser_wait_for_function among its siblings. It's clear but does not name or route against those siblings 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: nothing tells the agent when this is preferable to browser_wait_for_selector or browser_wait_for_network_idle, nor when to choose url_contains vs url_regex. Usage is left entirely to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read, but does not state whether the session must exist or be active, what happens on an unknown or expired session_id, or what the summary contains — and it does not flag any error behavior.

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

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

A single short sentence with no filler, which is structurally clean and front-loaded. But the brevity here is under-specification rather than true conciseness — the sentence is too thin to earn its place as the tool's only guidance.

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

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

An output schema exists, so return values need not be described. Still, with zero annotation coverage and a completely undocumented parameter, the description should at minimum clarify the session_id source and when this read is appropriate; those gaps make it incomplete for an agent to invoke correctly.

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

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

Schema description coverage is 0% for the single parameter, and the description does not compensate: it never explains what a session_id is, where it comes from (e.g., session_start), or its expected format. With one undocumented required parameter, the description adds no meaning beyond the schema's field name.

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 verb ("Get") and a resource ("one session summary"), and "one" weakly distinguishes it from the sibling session_list. However, "summary" is left ambiguous — it is unclear whether this returns full session state, metadata, or a condensed view — so the agent cannot tell precisely what it retrieves.

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

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

There is no guidance on when to use this tool versus session_list, session_state_paths, or session_get_policy, nor any prerequisite such as needing an active session. Usage must be inferred entirely 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 carries the full burden of behavioral disclosure. 'Get' implies a safe read, but there is no mention of auth requirements, error behavior for unknown sessions, or what 'runtime policy' encompasses. Only the barest hint of the operation type is conveyed.

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. It is efficient, though its brevity reflects under-specification rather than tight writing.

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

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

An output schema exists, so return values needn't be explained, and this is a simple single-parameter read tool. However, the absence of annotations, parameter documentation, and usage guidance leaves the definition barely adequate.

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

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

Schema description coverage is 0%, so the schema documents nothing about session_id. The description does not compensate by explaining the identifier's format or source, though the parameter name is largely self-explanatory.

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 (Get) and resource (runtime policy) with a clear scope (one session). It implicitly contrasts with the sibling session_set_policy, though it never names or explains the distinction 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?

No statement of when to use this tool versus session_set_policy, session_get, or session_state_paths is provided. The description offers no context or prerequisites, leaving the agent to infer usage entirely 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 carries the full disclosure burden. 'Active' usefully narrows the result set, but it doesn't say whether terminated/stale sessions are excluded, whether sessions are scoped per-account, or how the list relates to session_state_paths or browser_tab_list. For a zero-parameter read tool this is adequate but thin.

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 with the scope qualifier front-loaded and zero waste. It is only docked because the extreme brevity leaves obvious clarifying information unstated.

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?

Output schema exists, so return values need not be described, and there are no parameters to document. For a simple listing tool the definition is nearly sufficient; the remaining gap is the implicit relationship to session_get and the session-stop tools.

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 and the schema is trivially complete. Baseline 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?

States a specific verb and resource ('list ... sessions') with a scope qualifier ('active browser'). It distinguishes this from session_get/session_profile_list/session_proxy_list by the word 'active', though it never explicitly names an alternative, so the 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?

No when-to-use guidance and no mention of alternatives. The agent must infer that this is the discovery step before session_get or session_stop; nothing in the text says so.

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 for a destructive operation. It hints at two modes (metadata vs. entire directory) but says nothing about irreversibility, permissions, side effects, or whether running sessions are 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?

A single efficient sentence with no filler, front-loading the verb and resource. The trailing 'or entire profile directory' clause is terse to the point of ambiguity about the triggering condition.

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

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

An output schema exists so return values need not be described. However, for a destructive tool with zero annotations and 0% parameter coverage, the definition omits critical context: irreversibility, what exactly gets removed, and the effect of delete_user_data_dir.

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

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

Schema description coverage is 0%, so the description must explain both parameters. It alludes to the metadata-vs-directory distinction that maps to delete_user_data_dir, but never names the parameter, states the default, or clarifies what toggling it actually does. The required 'profile' parameter is entirely 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 (Delete) and resource (profile metadata / profile directory), and distinguishes two deletion scopes. It does not explicitly name or differentiate itself against siblings like session_profile_list or session_proxy_delete, but the core action is unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no warning about when deletion is appropriate or dangerous. The agent must infer all usage context 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?

No annotations are provided, so the description carries the full burden. It implies a read but never states read-only semantics, error behavior for an unknown profile name, or any auth/permission requirements for a session-scoped lookup.

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 the key information front-loaded and no filler. It is efficient, though arguably terse given the absence of 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?

An output schema exists, so return values need not be described, and there is only one parameter. However, with zero annotations and no error or identity resolution guidance, the definition is only minimally complete for an agent to call it reliably.

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

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

Schema coverage is 0%, so the schema only says 'Profile' is a string. The description adds genuine value by clarifying the accepted forms ('by name or account alias'), partially compensating for the coverage gap, but it gives no format or validation details.

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

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

States a specific verb (get) and resource (saved profile) with scope ('one'), which cleanly distinguishes it from the sibling session_profile_list. It does not explicitly name siblings, but the singular/plural split 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?

Usage is implied by 'saved profile' but there is no explicit when-to-use, no note on what happens if the profile is missing, and no pointer to session_get or session_profile_list as 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 behavioral burden. 'List' implies a safe read, but nothing states whether results are paginated, sorted, filtered by session, or require an active session – all plausible concerns given the session-scoped sibling set.

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 padding, which is appropriate for a trivial no-argument list operation. It is terse rather than wasteful, though it leaves room for one routing clause.

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

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

An output schema exists, so return values need not be explained, and a 0-param tool is simple. However, with no annotations and no hint about how this differs from session_list or session_profile_get, the definition is only minimally complete for an agent navigating a large sibling set.

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 of 4 applies; there is no parameter semantics to document and the description does not mislead about inputs.

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 ('List saved browser profiles'), which is unambiguous and distinguishable from mutation siblings like session_profile_set or session_profile_delete. It does not explicitly differentiate itself from the similarly named session_list or session_profile_get, 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?

There is no guidance on when to use this tool versus session_list, session_profile_get, or the other session_profile_* siblings. The agent must infer usage 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 provided, the description carries the full behavioral burden. It usefully discloses that the new fingerprint replaces the stored identity and that subsequent launches use it, but omits permissions, reversibility, failure modes, or whether the profile must already exist.

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 front-loaded with the action and effect, then parameter details, and all sentences carry useful information. The BrowserForge implementation detail is slightly non-essential but not harmful.

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?

Because an output schema exists, the description need not explain return values. It covers purpose, persistence, and the platform-family parameters well enough to invoke the tool, though it lacks usage routing and safety warnings that would make it fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It supplies the allowed os values ('windows', 'macos', 'linux') and a browser default ('chrome'), and its 'for a profile' phrasing implies the required profile argument. It still does not document the profile identifier format, and the stated browser default conflicts mildly with the schema's null default.

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

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

The description gives a specific verb (regenerate) and resource (fingerprint for a profile) and states the effect on the stored identity. It does not explicitly distinguish this from the sibling session_set_fingerprint, so it falls short of the top score.

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

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

The description explains what the tool does and its persistence effect, but gives no guidance on when to use it instead of session_set_fingerprint, session_profile_set, or other profile-related siblings. No when-to-use or when-not-to-use conditions are stated.

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

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

With no annotations, the description carries the full burden, and it does add real behavior: fingerprint is auto-generated on first launch if unset, fingerprint takes precedence over launch_options in the merge chain, and proxy_ref overrides launch_options proxy_ref. It still omits side-effect traits such as whether an unknown profile name silently creates one, persistence durability, and permission/auth requirements, so it is only partially transparent.

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 purpose is front-loaded in the first clause and the remaining sentences are dense with usable semantics rather than filler. It is long, but nearly every sentence carries new information about a parameter, so length is justified.

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

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

The output schema exists, so return values need no explanation, and the highest-risk parameters (fingerprint, launch_options, proxy_ref, warming_status) are explained. However, for an upsert mutation with zero annotation coverage, missing coverage of the required profile param and account_aliases leaves the definition incomplete.

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

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

Schema description coverage is 0% across 7 params, so the description must compensate. It documents launch_options (with a full key list), fingerprint, proxy_ref and warming_status semantics well, but leaves profile (the only required param), description and account_aliases entirely undocumented — a meaningful gap for the single required 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?

Opens with a specific verb+resource: 'Create or update a saved profile', which is an upsert clearly distinct from sibling session_profile_get, session_profile_list and session_profile_delete. It stops short of naming a sibling to route against, so it lands at 4 rather than 5.

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

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

No statement of when to prefer this tool over alternatives such as session_profile_regenerate_fingerprint or session_set_fingerprint, and no prerequisites (e.g. whether an active session or existing profile is required). The precedence notes about fingerprint vs launch_options fingerprint fields are about field merging, not tool selection.

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, yet it says nothing about permanence, whether deletion fails or is a no-op for unknown names, or what happens to live sessions using that proxy. 'Delete' implies destruction but no consequences are disclosed.

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

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

A single front-loaded sentence with zero filler, though its brevity is partly 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?

This is a destructive mutation with no annotations and no output guidance needed (output schema exists), but the description omits the behavioral context an agent needs to call it safely: what is removed, what breaks, and how an unknown name is handled.

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

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

Schema description coverage is 0% and the only parameter, proxy_name, is documented solely by its title. 'By name' merely restates the parameter name; it adds no format, case-sensitivity, or lookup-failure semantics to compensate for the coverage gap.

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