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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only hints at performing actions ('execute') but does not state side effects, permissions, reversibility, or what happens to the session. This is a significant gap for a tool that likely mutates state.

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

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

The description is extremely short (one sentence), but this is under-specification rather than effective conciseness. There is no front-loading of critical information because none is provided. It is not appropriately sized for a tool with four parameters and a complex 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?

For a tool that combines observation and execution, with no output schema and no annotations, the description is grossly incomplete. It does not explain how the plan is derived, what the output looks like, or how it interacts with sessions and leases. An agent cannot call this correctly based on the description alone.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no extra meaning to the parameters (intent, llm, lease, session); it does not explain their roles or relationships beyond what the schema already documents.

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 'Observe + execute the resulting plan in one shot' is abstract and does not specify a concrete resource or action. It implies a meta-operation combining observation and execution, but it is unclear what 'observe' and 'execute' refer to, and it does not differentiate from siblings like observe, click, or fill. The purpose is too vague to guide an agent.

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 instead of alternatives. It does not mention conditions, prerequisites, or exclusions, leaving the agent without any basis to choose between 'act' and the many other tools for observation or action.

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 full responsibility. It only states the action and use case, but does not disclose behavioral traits such as whether it modifies the session, requires specific permissions, or has side effects. The description is terse and leaves the behavioral contract largely opaque.

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

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

The description is a single, concise sentence that front-loads the core purpose. It is efficient and avoids redundancy, though it might be slightly too brief to fully inform the agent. Still, it demonstrates appropriate 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?

The description provides the essential use case but leaves out details like prerequisites for CDP connectivity (e.g., Chrome must be running with remote debugging) and what to do after attaching. Given the moderate complexity and absence of output schema, it is minimally adequate but not thorough.

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

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

Schema coverage is 100%, so all parameters (lease, cdp_url, session) are already documented with descriptions. The tool description adds no extra meaning about parameters, staying at the baseline of 3. It neither compensates nor repeats, which is acceptable given full schema coverage.

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

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

The description states a clear action 'Attach to an existing Chrome via CDP', distinguishing it from siblings like 'start' (which likely launches a new browser). It also provides a specific use case ('after manual login on a Cloudflare-walled site'), making the purpose 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?

It explicitly says 'use after manual login on a Cloudflare-walled site', giving a clear context where this tool is preferred. It doesn't explicitly mention alternative tools, but the context implies it's for attaching to a pre-existing session rather than starting fresh. Some guidance on when not to use it would improve it.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description carries a low burden. The description consistently indicates a non-destructive read operation, aligning with the annotations. It adds no additional behavioral context (e.g., what happens if the attribute is missing, or whether it returns null), but there is no contradiction.

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

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

The description is a single, focused sentence with minimal word count. It is front-loaded with the core action and resource, and every word contributes to meaning. This is an exemplary level of conciseness for a simple getter tool.

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

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

For a straightforward read-only attribute retrieval with a fully documented schema and safety annotations, the description covers the core need. It does not explain the return format, but given that the tool is simple and an output schema is absent, this is acceptable. The missing usage guidance is a minor gap but does not render it incomplete for basic invocation.

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

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

Schema description coverage is 100%, so all four parameters are documented in the input schema. The description itself adds no extra meaning beyond what the schema provides; it just restates the tool's purpose. Per the baseline rule, when schema coverage is high, a score of 3 is appropriate.

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

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

The description states a clear verb (Get) and resource (HTML attribute value from an element), which is specific. However, it does not explicitly distinguish itself from sibling tools like text, value, or html, which also retrieve element properties. The name 'attr' adds some clarity but the description alone doesn't differentiate from similar retrieval tools.

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

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

No guidance is provided on when to use this tool versus alternatives like 'text' or 'value'. The description only states what it does, not when it is the right choice. There is no mention of exclusions or alternative tools, leaving the agent to infer usage from the name and 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 of behavioral disclosure. 'Browser back.' only states the action without describing any side effects (e.g., history stack behavior, session impact, or state changes). It does not go beyond the bare action, leaving behavioral expectations underspecified.

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

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

The description is extremely concise with minimal words, fitting the simple action. There is no wasted text. However, it lacks any structural elements like front-loading key constraints, though for such a short description that is not a significant drawback.

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

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

The tool has 2 optional parameters with full schema coverage, but the description provides no context about navigation history behavior, session implications, or expected outcomes. There is no output schema, so the agent is left without understanding return values or side effects. For a simple action, this might barely suffice, but it leaves gaps for an agent needing to make informed calls.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters (lease and session). The description adds nothing about parameters or their semantics. With full schema coverage, the baseline of 3 is appropriate; no extra meaning is provided.

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

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

The description 'Browser back.' clearly indicates a navigation action (going back in browser history) with a specific verb and resource. It distinguishes implicitly from siblings like 'forward' and 'reload' via its verb, but does not explicitly name them. The purpose is clear, but slightly terse.

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. It does not mention conditions for use, exclusions, or contexts where other navigation tools would be more appropriate. The description provides zero usage direction.

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

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

Annotations already establish `readOnlyHint: true` and `openWorldHint: true`, so the description need not repeat that. It adds valuable behavior details: the return structure includes a `truncated` flag, indicating results may be limited, and it clarifies that the tool returns a comprehensive list. No contradiction.

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

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

Two sentences with zero fluff. The first sentence front-loads the purpose and return shape; the second explains how to act on results. Every word earns its place, making it easy to parse for an agent.

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

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

Given the moderate complexity (4 params, no nested objects, no output schema), the description thoroughly covers the return structure (`target`, `count`, `candidates` with fields, `truncated`) and how to consume it. It also mentions the `lease` token context. Nothing essential is missing for correct invocation.

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

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

Schema coverage is 100% (all params have descriptions), but the description adds significant semantic value beyond the schema: it explains the `target` syntax variants (`@eN`, `@text:`, `@label:`, CSS) and gives practical guidance for the `session` parameter on shared daemons (use a unique name). This goes beyond what the schema descriptions provide.

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 ('List'), a concrete resource ('every element a target resolves to'), and the intended purpose ('disambiguate an ambiguous locator instead of failing strict mode'). This clearly differentiates it from siblings like 'find' or 'count' by focusing on enumeration for disambiguation.

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

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

It explicitly describes when to use the tool: when a locator is ambiguous and would otherwise fail strict mode. It also instructs how to act on results with `index=N`, implying the follow‑up workflow. It doesn't mention alternatives or when not to use it, but the context is clear enough.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure. It only states the action without describing side effects, state changes, prerequisites, or failure cases. For example, it does not specify whether the target must already be visible or enabled, what happens if the target is not a checkbox/radio, or any permission or session dependencies. The minimal text does not meaningfully reveal behavior beyond the basic intent.

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, taut-but-concise sentence with no filler or repetition. It gets straight to the point and is appropriately sized for the simple action the tool performs. It does not waste words, though a slightly longer version could add clarity without becoming verbose.

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 simple tool (no output schema, no annotations, 100% schema coverage), the description is thin on operational details. The agent cannot tell whether the tool can handle already-checked controls, what 'checking' does to a radio that is already checked, or how it differs from a generic click beyond the label. The absence of usage guidance and behavioral nuances makes it incomplete for correct invocation without assumptions.

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

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

The input schema has 100% coverage with each parameter well described ('target' as '@eN or selector', 'session' guidance, and 'lease' context). The description adds no parameter-specific meaning (it only mentions the target type globally). According to the rules, with high schema coverage, the baseline is 3, which is appropriate.

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

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

The description 'Check a checkbox / radio' clearly states the specific action (check) and the resource types (checkbox/radio). It distinguishes itself from the sibling 'uncheck' by implying a positive action, and from generic actions like 'click' by naming the element types. It does not explicitly contrast with alternatives, but the verb-resource pairing is specific enough for an agent to understand the tool's purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that it is for checkbox/radio inputs only, nor does it advise avoiding it for other elements, nor does it reference the sibling tools (e.g., 'uncheck', 'click', 'toggle' not present). The agent is left to infer the preconditions and scope from the schema and 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?

Annotations only mark destructiveHint=true, so the description carries the safety burden. It adds critical context: dry-run by default, apply=true required to actually delete, never touches default/active/running sessions, and returns a per-category {count, bytes} report. This is strong behavioral disclosure beyond the annotation.

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

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

Two sentences with no filler: the first front-loads purpose and categories, the second covers safety and return format. Every clause earns its place.

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

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

Despite having 11 parameters and no output schema, the description covers the essential invocation context: what gets cleaned, default dry-run behavior, safety guarantees, and the return report shape. Parameter details are fully covered by the schema, so nothing critical is missing.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The description reinforces the apply semantics and category scope but does not add per-parameter meaning beyond what the schema already provides.

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

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

The description states a specific housekeeping purpose with concrete resource categories: stale profile dirs, superseded Chrome cache dirs, leftover Chrome lock files, regenerable caches, and the daemon log. This clearly distinguishes it from sibling session/profile deletion tools.

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

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

The description implies usage via 'Housekeeping' and explains the dry-run default, but it does not explicitly say when to prefer this tool over alternatives like profile_delete or vision_clear_cache. It gives no explicit when-not-to-use guidance beyond never touching active sessions.

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 of behavioral disclosure, yet it discloses nothing beyond the literal click action. Side effects (e.g., waiting for navigation, 'intercepted' failures, ambiguity resolution via the index parameter) are left entirely to the schema, which is a significant gap for an interaction tool.

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

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

A single efficient sentence with zero waste, front-loading the verb and target form. It is appropriately terse, though it perhaps errs on the side of being too spare.

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 an interactive tool with 6 parameters, no annotations, and no output schema, yet the description provides none of the behavioral context an agent needs: what happens after a click, how 'intercepted' failures and retries work, or how target ambiguity is resolved via index. Incomplete for a tool of this complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description merely restates what the target parameter already says ('@eN ref or selector'), adding no new meaning beyond the schema.

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

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

The description states a specific verb ('Click') and resource (an @eN ref or CSS selector), which clearly identifies the operation. It does not differentiate from sibling tools like dblclick, check, or uncheck, but the name plus target-form hints make the purpose unmistakable.

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 in the description on when to use this tool versus alternatives like dblclick, check, or hover. The session parameter hints at multi-step sequencing ('go→click→fill'), but the description body itself provides no explicit when-to-use or when-not-to-use 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?

With no annotations, the description must carry the burden of behavioral disclosure. It states that the page HTML is replaced 'wholesale', which implies a destructive, full-page overwrite, but it does not mention side effects such as clearing JavaScript state, form data, or event listeners. It also omits any mention of potential error conditions or the effect on the current session. The description is minimal and leaves significant behavioral aspects unspecified.

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

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

The description is a single, concise sentence that front-loads the core action and resource. It contains no filler and is immediately informative. This is an optimal length for a simple tool, earning a top score for conciseness and structure.

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

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

The tool has three parameters (one required) and no output schema, so the description should compensate by explaining usage context. Instead, it provides only a one-line summary. It does not mention the significance of the 'session' parameter for multi-step work on shared daemons, nor does it clarify that the change is immediate and irreversible. The description is incomplete for an agent to understand the full context, especially regarding parameter interplay and side effects.

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

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

The schema covers all parameters with descriptions, so the baseline is 3. The tool description does not add any extra meaning to the parameters; it does not clarify how 'html' interacts with 'lease' or 'session', nor does it emphasize the importance of unique session names on shared daemons (which the schema already notes). It adds no value beyond the schema, so a score of 3 is appropriate.

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

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

The description clearly states the action ('Replace the page HTML wholesale') and the resource (page HTML), and even names the underlying method (page.set_content). This makes it distinct from retrieval tools like 'html' or 'extract' in the sibling list. However, it does not explicitly differentiate from partial-update tools like 'fill' or 'type', relying on the word 'wholesale' to imply that. Still, the purpose 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?

The description offers no guidance on when to use this tool versus alternatives. It does not mention that this is for full replacements only, or when to prefer partial updates via 'fill' or 'type'. There is no mention of prerequisites, session handling, or contexts where it should be avoided. The agent is left to infer usage from the verb 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?

Annotations declare readOnlyHint: true, which is consistent with the description's 'Count' operation. The description adds little beyond that: it clarifies input forms but does not disclose the return type (e.g., integer) or behavior when no matches are found. Since annotations already cover safety, a baseline 3 is appropriate; the description adds minimal context.

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

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

One sentence, front-loaded with the action, and no redundant words. Every phrase earns its place, and the description is appropriately short for a simple operation.

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

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

For a tool with no output schema, the description should at minimum reveal what the return value is (a count of matching elements) and ideally when to prefer it over sibling tools. It only hints at the input. The absence of any usage context or return semantics makes this incomplete for an agent deciding between 'count' and 'find'.

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

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

The input schema already provides descriptions for all three parameters (100% coverage), so the tool description does not need to repeat them. The phrase 'for a selector or @eN ref' restates the 'target' parameter, but adds no new semantic detail. Baseline 3 is correct when the schema carries the documentation burden.

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

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

The description states a clear verb ('Count') and resource ('matching elements'), and specifies the input types (selector or @eN ref). It does not explicitly differentiate from sibling tools like 'find' or 'candidates', but the action of counting is distinct enough. A clear purpose but with room to 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?

No guidance on when to use this tool versus alternatives. It doesn't mention that 'find' returns elements rather than a count, or suggest 'count' when only a number is needed. The usage context is left entirely to the agent's inference, which is insufficient given the large set of sibling tools.

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

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

No annotations are provided, leaving the description the sole behavior source, but it only says 'Double-click,' offering no details about side effects (e.g., moving the mouse, waiting for visibility) or the result. It does not disclose whether the tool focuses the element first, whether it dispatches events, or whether it has side effects like toggling state or triggering both click and dblclick signals.

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 short sentence with no filler or redundant metadata, making it easy to parse. It front-loads the specific action and keeps the whole thing free of cumbersome detail.

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

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

Given a sufficiently parameter-rich schema (100%) and no output schema, the description is a straightforward tool description that will let a model invoke it. However, the context is still minimal—there's no reference on how failures are reported, how it handles hidden elements, or why it should be chosen over click, so a small but meaningful completeness gap remains.

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?

Parameter descriptions in the schema provide 100% coverage of the index, lease, session, target, and timeout_ms, so the description's job for parameters is light. It only adds a redundant note that the target can be '@eN ref or CSS selector,' the exact phrasing already in the target property.

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

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

The description states a clear verb, 'double-click,' and a resource type, '@eN ref or CSS selector,' making the action comprehensible. It doesn't explicitly contrast with tools like 'click' or 'hover' in the sibling list, so it's clear on its own but not as differentiated as a description that names the alternative.

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

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

The description offers no when-to-use or when-not-to-use guidance, and no reference to related tools such as 'click', 'hover', or 'press'. There is also no mention if it should be used with a specific session or selectors or if it plays a specialized role among the sibling tools.

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

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

With only readOnlyHint and openWorldHint in the annotations, the description carries the behavioral burden and does it well. It discloses the SPA-specific formless-controls group, the value-withholding behavior unless values=true, secret redaction heuristics, the best-effort quality, and the security warning about untrusted pages, which goes far beyond the schema and annotations.

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

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

The description is about 90 words across two sentences, front-loads the primary purpose, and each clause earns its place: the core return shape, the SPA extra, the field attributes, the value/redaction caveat, and the expected output shape. There is no fluff or redundancy.

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

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

Given there is no output schema, the description compensates by naming the return contract ({forms, count}) and the important per-field attributes. With all 8 parameters well-documented in the schema and 0 required, the only minor gap is a slightly more detailed shape of the form group under a formless-controls entry, but that is a small 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 100%, so the baseline is 3. The description adds meaningful semantics on top: it explains that a free-text field's typed value is withheld unless values=true, describes the secret-redaction heuristic, and frames the output locators as ready for fill/click. This goes beyond trivial restatement of the schema.

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

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

The description names a specific verb and resource: it builds a structured map of every form on the page, including a formless-controls group for SPAs. It clearly distinguishes itself from siblings like extract, extract_fields, or candidates by emphasizing ready-to-use locators for fill/click and by mentioning the real authenticated Chrome DOM.

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

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

The description gives strong usage direction: it presents locators as directly consumable by fill/click, and warns about when not to use values=true. It stops short of explicitly naming alternative tools or saying 'use X instead', so it lacks a formal when-not statement, but the context is largely clear.

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

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

With no annotations, the description carries the full burden. It only says the tool compares snapshots, but it does not disclose whether the operation is read-only, what happens if no previous snapshot exists, or any side effects on the session. The information is minimal and leaves important behavior unknown.

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

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

The description is a single, concise sentence that directly states the tool's action. It is free of redundant information and skims the clause name of the tool, but it leans toward under-specification because it omits any behavioral or output details. The form is efficient, though length is short of the needed depth.

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

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

The tool has a simple schema, but there is no explanation of what the diff result looks like (no output schema) or the relationship between target session and the snapshots being compared. The lease/session parameters are documented, but their impact on the mapping is unclear. The description does not cover the essential contextual gap, leaving an agent uncertain about return structure and operational assumptions.

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

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

Schema coverage is 100%, so the lease and session parameters are well documented in the input schema. The description adds no further meaning, not even clarifying how lease or session relate to the snapshots being diffed. This is a baseline 3, as the schema already handles the parameter descriptions and the description does not detract or add.

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

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

The description states a specific action ('diff') on a defined resource ('current snapshot vs the previous one'). It distinguishes the tool from sibling tools like map and map_compact, which generate snapshots rather than compare them, though the term 'snapshot' is not elaborated.

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

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

No guidance is given for when to use this tool versus alternatives, such as verify_map or expect. The description does not specify prerequisites, like the need for an existing snapshot or typical scenarios (e.g., comparing state before and after an action). Usage is only implied by the verb 'diff'.

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 mentions 'heuristically' but does not disclose that the tool likely clicks elements on the page, could make mistakes, or that dry_run is available to preview behavior. The description gives no insight into side effects, reliability, or edge cases, which is expected for an action-oriented heuristic tool.

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

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

The description is a single, focused sentence with no filler. It states the core purpose immediately and does not waste words.

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

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

For a tool that performs heuristic interactions with a page, the behavior is under-described. There is no mention of what happens when it works or fails, no side effects, no return value, and no guidance on how reliable the heuristics are. The rich parameter descriptions do not compensate for the lack of behavioral context.

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

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

Schema coverage is 100%, and each parameter already carries a detailed description in the schema. The tool description itself adds no additional parameter context beyond what the schema provides, so the value is purely at baseline level.

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

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

The description clearly states the action (dismiss) and the target (cookie/consent/newsletter banners), with the modifier 'heuristically' indicating an automated approach. No sibling tool has a similar purpose, so it is easily distinguished.

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

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

The description implies when to use the tool (to automatically dismiss banners) but does not explicitly state when not to use it or provide alternatives. For example, it doesn't note that it might misfire and that a manual click could be preferred. This is implied usage, not explicit 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?

The description adds a key behavioral nuance beyond the `openWorldHint` annotation: the JS runs in an isolated world so `window.X = ...` mutations are NOT visible to page JS. This is exactly the practical behavior an agent must know before calling eval. It also mentions that `eval_handle` is the alternative to retain references, which is actionable and not deductible from the annotation alone.

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

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

The description is a single sentence and front-loaded with the action, while still adding the critical isolated-world caveat and forwarding to `eval_handle`. It is a little dense with the semicolon-clause, but every piece earns its place. Nothing is fluffy 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?

For a tool with four parameters and a strong schema, the description covers the most important evaluation-context trap. However, it does not state what the caller should expect as a return value or how async expressions are handled, which agents often need to know when using an eval tool; leaves some usage ambiguity.

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

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

The input schema has 100% description coverage for all four parameters, so the description does not need to repeat parameter meanings. The description adds no extra intel about `expr`, `lease`, `session`, or `timeout_ms`, so it does not improve on what the schema now gives; the baseline of 3 applies.

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

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

The description states a specific verb and resource: it 'evaluate[s] a JS expression in the page.' It further clarifies the scope by noting the isolated context and the boundary on `window.X` mutations, and it differentiates itself from `eval_handle` by telling the caller when to use that sibling instead. An agent can then distinguish `eval` from the many other page-tools.

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

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

It explicitly provides an alternative: 'use eval_handle to retain references', which tells the agent when `eval` is insufficient. It also implies this tool is for cases where references are NOT retained. However, it does not define broader conditions (e.g., when it is better than `wait_fn` or extracting text) or list exclusions beyond the reference case.

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

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

The description discloses the composite nature and the challenge-wall check, and it mentions the return verdict shape. With only openWorldHint as an annotation, it adds meaningful behavioral context (e.g., it composes waits and checks, not just reads state). It doesn't go into side effects like timeout waits or screenshots, but those are already captured in the schema params, so this is adequate.

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

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

Three dense sentences with zero fluff. The purpose and usage are front-loaded, and the return format is stated compactly. Every sentence earns its place, and the description is immediately scannable.

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

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

Given the absence of an output schema, the description adequately explains the return format ({passed, failures[]}) and provides usage context. It covers the main use case (post-action verification) and the soft-blocked case. Minor gaps remain (e.g., no explicit mention of default timeout or screenshot auto behavior), but those are covered by the parameter schema, so the overall picture is complete.

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

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

Schema coverage is 100%, and the description does not add substantive meaning beyond what the input schema provides. It mentions that every check is optional, but that is already implied by all parameters being optional in the schema. No additional syntax or interplay details are explained.

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 precise verb ('Assert') with a specific resource ('the page reached an expected state') and lists the composed checks (element-state, page-text, URL, challenge-wall). It clearly distinguishes itself from sibling tools like is_state (single state check) and verify_url (URL only) by framing itself as a composite one-call gate.

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 tells when to use it ('Use after an action to confirm it landed') and what to avoid ('instead of stitching wait/text/url/screenshot calls'). It even handles the soft-blocked case, making the decision boundary crisp for the agent.

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

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

Annotations are minimal (openWorldHint only), so the description carries full burden. It discloses the internal pipeline (verify_url → auto-start → go → extract text), absence of default screenshot, fallback condition, ephemeral session behavior with auto-deletion, and that screenshots return as viewable images not base64. This goes well beyond the flag hints.

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 lengthy (~200 words) and front-loaded with the critical usage trigger. Some redundancy with schema exists (e.g., screenshot policy also in parameter description), but the extra context on session behavior and fallback logic justifies the length. The structure is coherent, moving from when-to-use to workflow to parameter nuances.

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

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

Given the tool's complexity (9 params, one required) and rich behavior, the description covers all essential aspects: triggers, workflow, screenshot policy, session handling, and output format (viewable image). No output schema exists, so the statement about return format is necessary and provided. Nothing critical for an agent to call it correctly is missing.

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

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

While schema coverage is 100%, the description adds substantial meaning: it explains the interplay of screenshot and min_text_chars (auto fallback threshold), clarifies ephemeral vs persistent session semantics, and notes that keeping the session open won't affect 'default'. These are not evident from schema alone.

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

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

The description opens with a precise trigger condition ('USE THIS WHEN WebFetch/WebSearch/curl GOT BLOCKED') and names the resource (URL) with a clear verb ('look at this URL'). It explicitly contrasts with sibling tools like WebFetch/WebSearch/curl and separate start/go/text calls, making the distinction unmistakable.

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

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

It gives explicit when-to-use ('when WebFetch/WebSearch/curl got blocked') and when-not-to-use ('unless you need multi-step interaction' to use separate calls), and recommends it as the 80% case for just showing a page. It also details parameter-driven usage (screenshot='always', 'never', session naming) with practical 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?

Beyond the readOnlyHint and openWorldHint annotations, the description discloses substantial behavioral detail: boilerplate stripping preserves headings/links/lists/code, output is always markdown text (never a base64 screenshot), results are capped by max_chars, links are deduped and absolute, data: URIs are dropped, and mode=main ignores target subtrees and rejects them. This gives the agent precise expectations for every mode without contradicting annotations.

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

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

The description is compact and efficient, using four sentences to cover purpose, use case, return guarantees, and an exhaustive inline mode reference. It front-loads the core value proposition and immediately supplies the key differentiator (authenticated scraping), with no filler or repetition.

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

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

With seven parameters, no output schema, and no openWorld or readOnly annotations (beyond the ones present), the description fully explains return behavior, mode variations, target scoping, and constraints. It covers all the details an agent needs to choose mode, set limits, and correctly invoke the tool in multi-step workflows, leaving no critical gap.

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

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

Although schema coverage is 100%, the description adds meaningful semantics to nearly every parameter: it explains what each mode returns, how target scoping is honored or rejected in main mode, how session names should be made unique to avoid collisions, and how lease tokens are threaded per-call and never read from server env. This is far beyond the schema's one-line descriptions.

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

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

Description states a specific action: extracting clean, LLM-ready Markdown from a page or subtree, with boilerplate stripped. It clearly differentiates from siblings like text, html, content, and extract_fields by emphasizing markdown output, subtree targeting, and its role as a drop-in for authenticated-page scraping. The four modes (markdown, links, assets, main) further define exactly what the tool produces.

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 a strong usage signal: use it for automated scraping of authenticated pages that stateless tools like Crawl4AI/Firecrawl cannot reach, and to get markdown rather than screenshots. It stops short of explicitly contrasting with internal siblings (e.g., telling when to use text or html instead), so it provides clear context but not exhaustive alternatives.

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

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

Annotations already carry readOnlyHint=true and openWorldHint=true, so the safety profile is set. The description adds value by specifying exactly what is read ('Reads text/attr/innerHTML only, never input values') and disclosing the return shape {fields, matched, misses, errors} with the misses/errors iterative-fix mechanism. No contradiction with the annotations — the read-only claim aligns with readOnlyHint=true.

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

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

The description is compact and front-loaded with the core purpose. Each sentence earns its place: purpose, grammar, target scoping, return shape, and read-only disclosure. It's dense but not bloated; could trim minor redundancy but overall efficient.

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

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

No output schema exists, so the description correctly takes on the burden of explaining the return shape {fields, matched, misses, errors}, which it does. It covers the field grammar, target scoping, and read-only scope. The remaining parameters (lease, session, node_cap, max_chars) are fully covered by the schema's 100% description coverage. Fairly complete for a complex 6-param tool.

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

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

Schema coverage is 100%, so the schema documents all six parameters. The description goes beyond the schema by explaining the selector grammar — name[]=array, sel@attr=attribute, sel@html=innerHTML, bare=text — giving semantic meaning to the suffixes the schema only lists. This is genuine additive value for the key fields 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 and resource: 'Declarative STRUCTURED extract' that takes a {name: selector} map and returns 'ONE JSON object of values in a single call'. It distinguishes itself from siblings like extract, text, html, and attr by framing this as a batch structured extraction against the authenticated Chrome DOM that stateless scrapers can't reach.

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

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

Provides clear context on when to use: against the real authenticated Chrome DOM that stateless scrapers can't reach, and for pulling multiple fields in one call. It notes misses/errors let you fix a selector without re-reading the page, and that it never reads input values (an implicit exclusion for value reads). However, it doesn't explicitly name sibling alternatives or give hard when-not-to-use conditions.

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

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

With no annotations provided, the description carries the full burden. It clearly states the destructive side-effect ('Clear an input and fill it with text') and explains that `use_secret` pulls from the encrypted vault. However, it does not disclose requirements like target editability, failure behavior, or whether it replaces existing text beyond clearing, leaving room for more transparency.

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

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

Two sentences, zero fluff. Core behavior is front-loaded, and the `use_secret` variant is mentioned immediately. 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?

Given the tool has 7 parameters and no annotations or output schema, the description is thin. The schema covers parameter semantics, but the agent gets no guidance on its distinct role among the many sibling tools (e.g., `type`, `press`). The description is sufficient for the case a minimal call but lacks context needed to route the agent to the correct tool for the job.

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

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

Schema coverage is 100%, so all parameters are documented in the schema. The description adds minimal value beyond the schema, merely restating that `use_secret` supplies the value. Baseline 3 is appropriate because the schema handles the heavy lifting and the description adds the clearing implication.

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

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

The description states the specific verb and resource: 'Clear an input and fill it with text.' This clearly distinguishes it from tools like type or select by emphasizing the clearing step. However, it does not explicitly name a sibling or explain when fill is preferred over type, so it earns a 4 rather than a 5.

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

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

No guidance is given about when to use fill versus alternatives like type, select, or check. The mention of `use_secret` is parameter-specific, not usage direction. There is no mention of prerequisites, when not to use it, or which sibling would be better for a given scenario.

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

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

Annotations already establish readOnlyHint=true and openWorldHint=true, so the safety profile is covered. However, the description adds no behavioral disclosure beyond those annotations—there is no mention of return values, scoping (e.g., shared vs. default session behavior), pagination, or what happens when nothing matches. It adds only a list of selector kinds, which is more purpose than 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 a single efficient sentence that front-loads the tool's purpose and the supported selector kinds. Every word contributes value; there is no filler, and it remains scannable and information-dense without being overly terse.

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

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

The tool has no output schema, and the description fails to explain what a successful 'locate' operation returns (an element reference? a locator token?), which is needed for downstream chaining with click/fill/expect. While the schema covers parameters and annotations cover safety, the description is not complete enough for an agent to confidently use the result of this tool; combined with the absent usage guidance, this is a notable gap.

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

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

Schema description coverage is 100%, so the schema already documents the parameters thoroughly, including the enum-like values for kind and the nuanced behavior of lease and session. The description's mention of semantic strategies (text/label/placeholder/role/...) adds a lightweight overview but no new meaning beyond what the schema already provides, so the baseline 3 is appropriate.

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

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

The description states a specific verb ('locate') on a clear resource ('elements') and enumerates the supported semantic strategies, making the tool's function recognizable at a glance. It does not explicitly contrast itself with sibling tools like vision_find or candidates, so it stops short of full differentiation, but the description is unambiguous about WHAT it does.

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

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

The description gives no guidance on when to use find versus alternatives such as vision_find, observe, or candidates, nor does it state any exclusions or prerequisites. It merely restates the tool's own mechanism (semantic strategy) without providing context on when this tool is the right choice among the many sibling locator and inspection 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 present, the description must carry all behavioral disclosure. It states only the core action and the absence of clicking, but does not mention side effects such as potential scroll-into-view, focus events firing, or behavior when the element is not visible. This is a minimal disclosure; agents are left to infer behavioral consequences.

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

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

A single sentence with no filler. The verb and scope are front-loaded, and the clarifying parenthetical adds key information without verbosity.

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

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

For a simple low-level interaction tool, the description conveys the primary operation. However, it omits any context about typical usage patterns, side effects, or what the tool returns (if anything). Given the lack of annotations and output schema, slightly more detail could be expected, but the core call is already actionable.

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

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

Schema description coverage is 100%, and the description itself adds no extra parameter meaning. It does not elaborate on target formats, session handling, or timeout semantics, which are already covered by the schema. Baseline 3 is appropriate when the schema does the explanatory work.

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

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

Description clearly states the action (focus) on a specific resource (an element), and the parenthetical 'without clicking' distinguishes it from sibling click and interaction tools. Even without naming a sibling, the exclusion of clicking makes the scope 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?

The phrase '(without clicking)' implies a usage scenario: use this when you need to focus without triggering a click. However, it does not explicitly say when to prefer this over hover, click, or other alternatives, nor does it provide any context about prerequisites or typical use cases.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Browser forward.' without explaining what action occurs (e.g., history navigation), whether it affects the current session, or any side effects. The agent is left without information on what to expect.

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

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

The description is extremely brief, but this is under-specification rather than effective conciseness. It lacks essential details about the tool's purpose, making the single sentence unhelpful. It does not front-load any key information because there is no informative content.

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

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

Given that this is a browser navigation tool with no output schema and no annotations, the description is severely incomplete. An agent cannot infer when to use it, what it does beyond a vague 'forward', or what the expected result is. The tool likely requires explanation of history navigation and session context.

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

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

Schema description coverage is 100%, meaning both 'lease' and 'session' are documented in the input schema. According to calibration guidance, the baseline is 3 when schema coverage is high. The description adds no additional meaning beyond what the schema already provides, but it does not contradict or confuse parameter usage.

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

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

The description 'Browser forward.' is essentially a restatement of the tool name with the word 'browser' added. It does not specify what 'forward' means (e.g., navigate to next page in history) nor does it distinguish from siblings like 'back' or 'go'. This is a tautology, providing no additional clarity to the agent.

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 'back', 'reload', or 'go'. The description does not mention any context, preconditions, or scenarios where forward is appropriate. No exclusions or alternatives are indicated.

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

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

With no annotations provided, the description carries the full burden. It reveals the 'omit both to clear' behavior but does not disclose side effects (e.g., how subsequent operations are affected), what happens if no matching frame is found, or whether this operation requires any session/lease handling. The behavioral disclosure is minimal.

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, tightly worded sentence with no redundancy. The main action and the edge case of clearing are front-loaded. It earns its place with zero 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?

For a simple state-switching tool, the description covers the core function but misses details like what happens when both name and url are specified (which takes precedence) or the behavior when no frame matches. With a simple schema and no output schema, a bit more completeness could be expected, but it is adequate for a basic switch operation.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description matches the 'name' and 'url' parameters but adds no additional semantics, such as precedence when both are provided or how they interact. The lease and session parameters are not mentioned in the description, though the schema fully documents them.

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

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

The description clearly states the verb 'Switch', the resource 'active frame', and the method 'by name or URL substring'. It also notes the clearing capability, which distinguishes it from the 'frames' listing tool. The purpose is immediately clear and unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention any conditions for use, exclusions, or refer to sibling tools like 'frames' or 'page_switch'. The description simply states the operation without contextual routing.

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

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

With no annotations provided, the description carries the full burden. The verb 'List' implies a read-only operation, and the output fields are stated, but no additional behavioral context is given (e.g., session dependence, lease handling, or side effects). It is adequate for a simple list tool but not rich.

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

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

A single, front-loaded sentence that states the action, resource, and output fields with zero wasted words. It is appropriately sized for the tool's simplicity.

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

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

The description covers the return contents (name, url, depth, active flag) despite the lack of an output schema. It does not mention return format or error conditions, but for a straightforward list operation with well-documented optional parameters, it is nearly 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 100%, so the schema already documents both parameters (lease and session) with useful detail. The description adds no parameter-specific meaning, but the baseline of 3 applies because the schema handles the semantics.

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

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

The description uses a specific verb and resource ('List all live frames') and enumerates the output fields (name, url, depth, active flag). It clearly distinguishes itself from the sibling 'frame' tool by targeting all live frames rather than a single frame.

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

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

The description implies usage when you need to enumerate frames, but it provides no explicit guidance on when to use this tool versus the 'frame' sibling or other navigation tools. There are no stated exclusions or alternative routing.

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

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

With no annotations, the description must carry the behavioral burden. It does communicate the key intended workflow: navigate, then extract via extract/text/html/map. However, it does not say anything about side effects, session persistence, failure modes, or what the tool actually returns after navigation, which leaves clear gaps.

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

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

The first sentence is front-loaded with the core verb, resource, and companion tools, while the second lists concrete trigger cases. The second sentence is a bit long, but each item earns its place and the description avoids filler.

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

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

For a navigation command, the description covers the main use cases and is sufficiently open-ended for an agent to know when to invoke it. It lacks an explicit statement of return behavior or output semantics, but no output schema exists, and the surrounding sibling-tool context covers the broader workflow.

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

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

The schema already covers all 5 parameters, and the description adds no parameter-specific details. Baseline 3 is appropriate because the schema is doing the explanatory work; the description's role is broader usage guidance rather than parameter enrichment.

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

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

The description clearly states the tool navigates to a URL in a stealth browser and that it pairs with extract/text/html/map. It names several triggers and mentions explore as a co-option, but it does not sharply distinguish go from explore or other browsing siblings, so it is not a full 5.

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

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

The description is explicit about when to reach for this tool: when WebFetch/curl is blocked by 403s, Cloudflare/DataDome challenges, login/paywalls, or JavaScript-only pages, and when a real browser is needed. It names the alternative class (WebFetch/curl) and the behavioral conditions, leaving little ambiguity about 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?

With no annotations, the description carries the full burden of behavioral disclosure. 'Briefly outline' suggests a temporary visual effect, but it does not state whether the page is modified, how long the outline lasts, whether it requires the element to be visible, or what side effects occur.

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 filler. It states the action, the target, and the purpose efficiently.

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

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

For a tool with no annotations and no output schema, the description is too thin. It omits usage guidance, behavioral details, and any sense of what the agent should expect after calling it, leaving the agent to infer important context from the parameter schema alone.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds no extra parameter meaning beyond restating that target is an '@eN ref or selector', which is already in the schema.

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

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

The description states a specific verb ('outline') and resource ('an @eN ref or selector') and gives the purpose ('visual debugging'). It is clear what the tool operates on, but it does not differentiate itself from visual siblings like screenshot_annotate or observe.

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

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

The phrase 'for visual debugging' implies when the tool is useful, but there is no explicit guidance on when to choose highlight over alternatives, nor any when-not-to-use or exclusion criteria.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the action. It does not mention side effects, prerequisites (e.g., element visibility), what happens on failure, or interactions with lease/session parameters.

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 waste. It is concise, though it borders on under-specification rather than being genuinely informative.

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

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

The description is minimal and does not cover expected behavior, edge cases, or return expectations. It omits details about waiting, failure handling, or how index/session options affect the action, leaving the agent without critical contextual information.

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 description adds no parameter-specific meaning, but the schema already documents all four parameters with high coverage (100%). Since the schema handles parameter semantics, the baseline of 3 applies.

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

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

The description clearly states the action ('Hover') and the target ('an element'), which distinguishes it from sibling tools like click, focus, or check. It is not a tautology and is not misleading, though it lacks specificity about the kind of element or context.

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

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

There is no guidance on when to use hover versus alternatives such as click or focus. The description provides no contextual cues or exclusions, leaving the decision entirely to the agent's inference.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description does not contradict these and adds minimal behavior detail beyond noting target selection options. It does not describe output format or any potential side effects, but for a read-only tool that is acceptable given annotations.

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

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

The description is a single, front-loaded sentence with no wasted words. It communicates the core functionality and gives target examples compactly. Perfectly concise for a tool of this simplicity.

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

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

For a read-only tool with three optional parameters and a full parameter schema, the description covers what is needed. It implies the return value (HTML) and provides target syntax guidance. It does not mention output encoding or pagination, but such details are likely irrelevant for a one-shot HTML fetch, and the tool is simple enough that this is not a significant gap.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description adds concrete examples ('@text:Foo', '@label:Email') that slightly illustrate the target syntax, but largely repeats the schema's target description. Since the baseline for full schema coverage is 3, this is appropriate; it does not significantly compensate for anything missing.

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

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

The description clearly states the tool retrieves HTML, either the whole page or a targeted element via @eN, @text:Foo, @label:Email, or CSS selectors. It is specific about what it returns, but it does not explicitly differentiate from siblings like 'text' or 'extract', though the examples imply HTML output.

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

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

No guidance is given on when to use this tool versus alternatives. With many sibling content-retrieval tools (text, extract, extract_fields), the description does not mention exclusions or direct users to pick it specifically for HTML needs. Usage context is only implied by the verb 'Get HTML'.

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

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

No annotations are present, so the description bears full responsibility for disclosing behavior. It states that humanize is disabled for the current session but does not explain side effects, reversibility, or any state changes that might affect other tools. The description is minimal and leaves the agent without details on persistence or prerequisites.

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, succinct sentence that directly states the action. There is no fluff or redundant phrasing, and the key information is front-loaded. It is an exemplar of conciseness for a simple tool.

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

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

For a simple toggle tool, the description is adequate in stating the core operation, but it omits any interaction with the 'session' parameter (even though the schema covers it) and does not describe expected outcomes or edge cases. Given no output schema and no annotations, a bit more context about the impact would improve completeness, but it is not critically 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 100%, so the schema fully documents both 'lease' and 'session' parameters. The description adds no additional parameter semantics, but the high coverage means the baseline of 3 is appropriate; no bonus is needed.

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

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

The description clearly states the action (disable) and the resource (humanize for current session). It is concise and unambiguous, though it does not explicitly differentiate from siblings like humanize_on or humanize_status; the opposite relationship is implied by the name and context.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention humanize_on, humanize_status, or any conditions for enabling vs disabling. The agent must infer appropriate usage from the tool name alone, which is insufficient for a clear 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 burden of behavior disclosure. It reveals actual behavioral traits (Bezier paths, gaussian dwell, sine scrolling) and the session scoping. It does not disclose persistence or reversibility details, but for a simple toggle the effect is reasonably aired.

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

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

Single sentence is front-loaded with the action and scope, with specific details cleanly parenthesized. No wasted words; efficiently structured.

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

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

For a simple, zero-required-argument toggle with no output and no annotations, the description provides enough to know the purpose, scope, and a few implementation details. It could mention how it interacts with the 'mouse' tool or how to disable it, but these are minor given the low complexity.

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

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

The schema has 100% coverage for both optional parameters ('lease' and 'session'), including usage guidance for stateful steps. The description itself adds no parameter-specific meaning, leaving the burden to the schema, which is acceptable.

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

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

The description uses a specific verb ('Enable'), a resource ('humanlike mouse'), and concrete behavioral modifiers (Bezier paths, gaussian dwell, sin scroll). It clearly distinguishes this from the sibling tools 'humanize_off' and 'humanize_status' by specifying the enabling action.

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

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

The description implies the usage context ('for current session') but gives no explicit guidance about when to avoid it or which sibling to use instead. It does not mention that 'humanize_off' should be used to disable the mode or that 'humanize_status' could verify state, so the guidance remains implicit.

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

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

With no annotations provided, the description carries the full burden of revealing behavior. The use of 'Report' implies a read-only operation with no side effects, which is a key behavioral trait. It does not mention any side effects or required preconditions, but for a simple status query this is sufficient.

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

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

The description is a single, concise sentence that directly conveys the tool's purpose. There is no unnecessary detail or redundancy, making it highly efficient.

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

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

For a straightforward status-check tool, the description is complete. It tells the user exactly what the tool does (report humanize status) and for which scope (current session). No additional context is required to use the tool 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?

The tool description does not add any additional meaning to the parameters beyond the schema. The schema already describes both optional parameters (lease and session) with clear explanations. Since schema coverage is 100%, the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: reporting whether humanize mode is on for the current session. It uses the specific verb 'Report' and identifies both the resource (humanize) and the scope (current session), making it easy to distinguish from siblings like humanize_on and humanize_off.

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 does not explicitly state when to use this tool versus alternatives. While it is implicitly a status check before enabling or disabling humanize mode, it lacks direct guidance on when to prefer it over humanize_on or humanize_off. The context is clear but the guidance is not provided.

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

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

With no annotations, the description must convey behavioral traits. It does not disclose side effects (likely read-only), return format (presumably boolean), behavior on failure (throws vs. returns false), or whether it waits for a condition. The phrase 'Check element state' is minimal and leaves critical runtime semantics unspecified.

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

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

The description is a single sentence, front-loading the purpose with an enumeration of states. It is concise and wastes no words. However, it could be slightly more informative without losing 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?

No output schema exists, so the description should explain the return value, but it does not. It also does not address how the four parameters cooperate or propose examples. The complexity is moderate (4 params), and the description is too thin to be complete.

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

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

Schema description coverage is 100%, so parameters are already documented. The tool description adds no additional meaning beyond the schema, such as how 'state' interacts with 'target' or typical usage patterns. Baseline score of 3 is appropriate since the schema carries the burden.

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 ('Check') and resource ('element state') with a list of example states. Distinguishes itself from sibling tools like 'check' (which likely toggles a checkbox) by focusing on state verification. Clear purpose, though it doesn't explicitly contrast with any sibling.

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

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

Provides no guidance on when to use this tool versus alternatives. No mention of how it fits into workflows (e.g., assertions, wait conditions) or when not to use it. The description only states its function, leaving usage 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?

With no annotations, the description is the sole source of behavioral insight, but it provides only the action 'Press a key combination' and no extra information about side effects, focus requirements, key-form limitations, or error behavior. It is a thin translation of the tool's 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?

The description is a single sentence with no filler. It immediately states the purpose, then provides illustrative examples, earning its place and keeping the text attention-efficient.

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

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

For a simple tool with one required and two optional parameters, the core action is stated enough, but it lacks guidance on when to choose this over the many sibling input tools (press, type, click). The existence of the 'session' and 'lease' parameters implies multi-session complexity that the description doesn't explain. It's adequate but leaves gaps.

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

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

The description adds concrete key-string syntax examples ('Control+A', 'Enter') that are more detailed than the schema's terse 'Key combo'. This helps the agent pass valid values for 'keys', though it does not clarify the optional 'lease' or 'session' beyond their schema descriptions.

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

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

The description clearly states the verb 'press' and the resource 'key combination', with substantive examples ('Control+a', 'Enter'). However, it does not explicitly differentiate this from sibling tools like 'press' or 'type', so it lacks a clear distinguishing statement but remains 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 or how to route between similar tools. The description only explains the action without any 'when' / 'when-not' context, leaving the agent without decision-support.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the Playwright mode detail, which is minor. No behavioral contradictions, but nothing else is disclosed about default behavior or side effects.

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 concise sentence that front-loads the tool's purpose and key detail (Playwright mode). No fluff, though it could benefit from a brief usage note.

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

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

No output schema is provided, so the description should explain what the snapshot returns or how @eN refs are used, but it doesn't. It also lacks guidance on when to use snapshotting in a multi-step workflow, making it adequate but not 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 100%, so the schema already documents all parameters. The description adds no parameter-specific meaning beyond what the schema provides, earning the baseline of 3.

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 ('snapshot') and resource ('actionable elements') with a clear outcome (assign @eN refs) and implementation detail (Playwright aria_snapshot mode='ai'). This distinguishes it from siblings like map_compact, though it doesn't 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?

No guidance on when to use this tool versus alternatives (e.g., explore, observe, map_compact). The description only states what it does, leaving the agent to infer 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?

Annotations already declare readOnlyHint and openWorldHint, and the description adds valuable behavioral detail about output format, state preservation, and the meaning of `bbox` as real Chrome geometry. It does not contradict annotations and goes beyond the structured metadata.

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

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

The description is a single dense sentence that front-loads the purpose and format, with no filler. It is efficient given the technical content, though slightly terse for a first-time reader.

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

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

With no output schema, the description provides a format template and explains both flags' effects, which is sufficient for a read-only mapping tool. Minor gaps like empty-snapshot behavior or edge cases could be added but are not critical.

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

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

The schema covers all parameters at 100%, but the description enriches understanding of `interactive` and `bbox` with concrete examples and clarifies the output format. This adds value beyond the schema, exceeding the baseline for high coverage.

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

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

The description clearly states the tool renders a token-efficient snapshot with a specific per-element format, which distinguishes it from the generic `map` sibling. However, it does not explicitly name the alternative tool, leaving some differentiation 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?

The token-efficiency hint implies a use case, and the `interactive`/`bbox` flags suggest conditional outputs, but there is no explicit guidance on when to choose this over `map` or `diff_map`, nor mention of scenarios where it should be avoided or prerequisites.

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

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

With no annotations provided, the description carries the full transparent burden. It only says 'Mouse control at pixel coordinates' but does not disclose that it moves the actual cursor, that down/up actions are stateful, that steps controls animation speed, or that the tool might affect a shared display. Critical behavioral context is absent.

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

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

The description is a single concise sentence with no wasted words, but it is under-specified rather than appropriately sized. It is front-loaded with the core purpose but lacks structural detail. Conciseness is good but at the expense of usefulness.

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 tool has 9 parameters, no output schema, and no annotations. The description does not explain the supported actions, coordinate conventions, button states, or session handling. Given the tool's complexity, the description is far too minimal to allow correct invocation without external knowledge.

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 56% (5 of 9 params have descriptions), yet the tool's description adds nothing about parameters. The undisclosed params x, y, dx, dy are ambiguous (absolute vs delta? coordinate origin?). The description does not compensate for the gaps in the schema, leaving an agent to guess their semantics.

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

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

The description states a clear verb and resource: 'Mouse control at pixel coordinates.' This defines the tool's purpose precisely enough to distinguish it as low-level mouse manipulation, though it does not explicitly contrast with sibling actions like click, dblclick, or hover. It is specific about coordinates but leaves the range of actions implicit in the action parameter.

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

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

No guidance is given on when to use this tool versus alternatives like click, dblclick, hover, or scroll. The description does not mention that this is a low-level primitive or recommend conditions for its use. An agent would have to infer from the parameter names that it might be used for raw input, but that is not 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?

The description adds the key behavior that the tool plans without executing, which is important safety context. However, with only openWorldHint as an annotation, the description does not disclose caching behavior, the optional LLM dependency, or what happens to lease/session state, leaving part of the behavioral burden on the schema descriptions.

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

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

A single sentence with no filler, focused on the core purpose and key limitation. It is appropriately sized and the main idea is front-loaded.

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

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

With no output schema and only a bare description, an agent cannot tell what shape the planned 'verb + target' takes, how to consume the return value, or how to chain observe into a later execution step. The description gives the gist but leaves critical operational details 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 100%, so baseline is 3. The description only mentions 'intent' generically and adds no additional detail about llm, force, lease, or session; all parameter semantics are already in the schema.

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

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

The description states a specific verb ('plan') and a clear resource ('verb + target for an intent'), and the phrase 'without executing' distinguishes it from execution-focused siblings like click or type. It does not explicitly call out a sibling that does the same thing, so it does not fully achieve the 5-level distinction.

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

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

There is no explicit guidance on when to use this tool versus alternatives, no excluded scenarios, and no condition such as 'use this before act' or 'instead of explore'. The 'without executing' clause implies a planning use-case, but that is not enough actionable guidance for an agent selecting among many similar planning/observation 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 provided, the description carries the full burden. It discloses the key side effect (next tab becomes active), which is helpful, but does not mention that closing is irreversible, what happens if only one tab exists, or whether the action is destructive. It also doesn't clarify that it operates within the context of a specified session.

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

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

The description is a single, focused sentence that states the action and its immediate effect with no wasted words. It is efficiently structured and front-loaded.

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

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

The description is minimal and adequate for a simple close operation, but it omits edge cases (e.g., closing the last tab), the return value, and the relationship to the session parameter. Given the large set of sibling tools and the optional session parameter, the description could be more explicit about scope, making it moderately 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?

The schema already documents both parameters (lease and session) with detailed descriptions and 100% coverage. The description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

The description states a specific action ('close') on a specific resource ('the current tab'), and notes the immediate consequence (next tab becomes active). This clearly distinguishes it from siblings like page_new (create tab) and page_switch (switch active tab).

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

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

The description implies when to use it (when you want to close a tab) but provides no explicit guidance on when not to use it or which alternative tools (e.g., session_close for closing an entire session, page_switch for changing active tab) to prefer. It lacks exclusions or comparative 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?

With no annotations, the description must carry the behavioral burden. It clearly discloses the two main effects (open and switch), but does not mention side effects like session handling, whether the previous tab remains active, or any permission/lease requirements. It is minimally adequate but lacks depth.

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 that is front-loaded with the core action and effect. There is zero wasted wording and the structure is optimally concise for the stated purpose.

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

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

The description covers the tool's basic function, but given the absence of annotations and output schema, it lacks detail about return values, session side effects, or how the new tab integrates with existing sessions. The 100% schema coverage compensates for parameters, but not for broader behavioral context.

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

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

Schema description coverage is 100%, so both parameters (`lease` and `session`) are fully documented in the schema. The description itself adds no parameter-level meaning, so a baseline score of 3 is appropriate.

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

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

The description states a specific action ('Open a new tab') and an immediate effect ('switch to it'), which clearly distinguishes it from siblings like `page_switch` (which only switches) and `page_close`. The verb and resource are direct and 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?

The description gives no guidance about when to prefer this tool over alternatives such as `page_switch`, `go`, or `attach`. It does not mention any conditions, exclusions, or use cases beyond the bare operation, leaving the agent to infer when it is appropriate.

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 disclosing behavior. It only says 'List all open browser tabs' without clarifying scope (e.g., does it include all sessions or just the default? does it return an empty list or error?), any side effects, or whether it respects leasing. The ambiguity around 'all' versus the optional session parameter 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?

The description is a single, efficient sentence that front-loads the action. There is zero waste, and it gets straight to the point. Perfect for a simple list operation.

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

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

There is no output schema, so the description should explain what the returned list contains (e.g., array of tab objects with titles/URLs). It also doesn't address the behavior across sessions or whether leasing affects the result. For a tool with optional session scoping, the missing details about scope and return format make it 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 100%, and both 'lease' and 'session' have clear descriptions. The tool description adds nothing about parameters, which is acceptable since the schema already explains them. Baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific verb (List) and resource (all open browser tabs), making the core purpose clear. However, it doesn't explicitly differentiate from sibling tools like 'frames' or 'content', though the concept of listing tabs is distinct enough that an agent would likely understand its role without extra clarification.

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

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

The description provides no guidance on when to use this tool versus alternatives such as page_new or page_switch. The schema's note about using a unique session name for stateful work gives some context, but that's parameter-level advice, not tool-selection guidance. An agent has to infer that 'pages' is the right call for getting an overview of open tabs.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure, but it only states the action. It does not mention side effects (e.g., changing the active tab), behavior when the index is out of range, or any impact of the lease or session parameters. Minimal behavioral detail is disclosed.

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

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

The description is a single, concise sentence and is front-loaded with the core action. It avoids filler and repetition, though it is slightly sparse; however, for such a simple action the length is acceptable.

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 the schema describes all parameters, the tool is part of a large set of page/session tools and has lease and session conditions that an agent must understand to call it correctly. The description lacks operational context, and with no output schema or annotations, the agent is left without guidance on when or how to use this effectively among many similar 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 parameter describing coverage is 100%, so the schema fully documents index, lease, and session. The description itself adds no parameter-level meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource, 'Switch to tab by index', which is clear and unambiguous. It distinguishes this from navigation tools (go/back/forward) by specifying index-based tab selection, though it does not explicitly name alternative siblings.

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

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

The description provides no guidance on when to use this tool versus sibling tools like 'pages', 'page_new', 'page_close', or 'session_switch'. There is no mention of criteria such as having a tab index available or handling multiple sessions, leaving the agent to infer appropriate use 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?

There are no annotations, so the description carries the full behavioral burden. It only states that the current page is saved as a PDF, without disclosing side effects, file overwriting behavior, required permissions, or return status.

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

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

A single sentence with no filler, stated in a direct and front-loaded fashion. It is terse but appropriate for such a simple operation.

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 complete schema coverage and a clear one-line purpose, an agent can invoke the tool minimally. However, with no output schema and no behavioral or usage context, some important aspects of a successful call are left unstated.

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

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

Schema coverage is 100% and parameter descriptions already cover all fields. The main description adds no extra meaning beyond implying path is the output destination.

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?

'Save the current page as PDF' names a specific verb, resource, and output format. It is clear and distinct from sibling tools like screenshot, 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?

No guidance on when to use this tool versus screenshots or other exports. No prerequisites are mentioned, and the optional session/lease parameters are left unexplained in the description.

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 of disclosure. It states the core action (press a key on an element) but does not reveal potential side effects, prerequisites (e.g., element focus requirements), failure behavior, or whether it simulates a real user input. This is minimal but not misleading.

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

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

The description is a single, focused sentence that includes a useful example. It is front-loaded with the action and avoids any filler, making it immediately actionable and easy to parse.

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

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

For a simple operation with well-described parameters and no output schema, the description is largely sufficient. An agent can correctly call it with target and keys. The only gaps are behavioral nuances (e.g., whether the element must be in view or interactive), but these are minor given the tool's simplicity.

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

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

The schema provides 100% parameter coverage, so the baseline is 3. The description adds a small illustrative example (Enter on @e3) that improves understanding of the target and keys parameters, but it does not provide additional semantics beyond the schema's own descriptions.

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

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

The description uses a specific verb 'press' with a resource 'a specific element' and provides a concrete example (Enter on @e3). This clearly distinguishes it from sibling tools like 'type' (typing text) and 'keys' (likely global key presses), making the purpose 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?

The description does not explicitly mention when to use this tool over alternatives like 'keys' or 'type'. It implies usage when you need to send a key press to a specific element, but it lacks explicit conditions, exclusions, or references to other tools, leaving the agent to infer the appropriate 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the destructive action ('delete') without any details on consequences, reversibility, permissions, or effects on associated sessions. It neither warns about permanent deletion nor explains what happens to dependent data, leaving the agent blind to important safety considerations.

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, compact sentence that is front-loaded with the core action and resource. There is no redundant filler, and the alias clarification is brief. However, it might be slightly too terse given the lack of supplementary context, but it earns high marks for efficiency and structure.

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 operation with three parameters, no output schema, and no annotations, yet the description provides only the core action. It omits critical context such as success/failure behavior, prerequisites (e.g., whether the session must be released), and potential side effects. The description is inadequate for an agent to safely invoke this tool without additional external knowledge.

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

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

Schema description coverage is 100%, meaning all parameters are already documented in the input schema. The description adds no additional insight into the parameters or how they interact beyond what the schema states, so the baseline of 3 applies. It does not clarify the lease token semantics or session targeting beyond the schema's own explanations.

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

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

The description clearly states the action ('Delete') and resource ('profile directory'), and explicitly identifies itself as an alias of 'session_delete', which distinguishes it from other session/profile management tools. The agent immediately understands what the tool does and that it is equivalent to another available tool.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives beyond noting it is an alias of session_delete. This implies either tool can be used interchangeably, but there is no discussion of specific scenarios or exclusions. The presence of the alias hint gives some direction but fails to clarify when to prefer profile_delete over other sibling tools like session_close or session_delete.

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

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

The description only says 'List' which implies read-only, but it does not disclose effects of the optional 'session' and 'lease' parameters on the result, nor does it state any permissions, side effects, or observable behavior such as whether it returns a grouped list. With no annotations, the description carries the full burden of behavioral disclosure and is insufficient.

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 that immediately states the action and result, followed by an alias note. There is no redundant phrasing and 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?

The description does not define 'active one' or what the output looks like, and it never references the optional 'session' or 'lease' parameters, the tool has no output schema and no annotations, leaving the agent to infer details from the parameter schemas alone. This is incomplete for a tool that lists all profiles and indicates an active one.

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

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

The schema provides full descriptions for both parameters, so the baseline is 3. The description itself does not mention the parameters, so it adds no extra meaning beyond already structured data; it does not clarify how 'session' or 'lease' would alter the listing output.

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

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

The description states the exact action ('List all profiles') and result ('the active one'), and explicitly notes it is an alias of session_list, giving agents confidence in the behavior. This clearly distinguishes it from profile_use, profile_new, and similar 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 tool instead of session_list or any other listing tool. The alias note hints that they can be used interchangeably, but there is no explanation of scenarios like checking the active profile before using profile_use, so an agent cannot make a justified choice.

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

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

With no annotations provided, the description carries the full burden. It does not disclose side effects, permissions, or behavior if the profile already exists, leaving transparency minimal for a state-changing operation.

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 concise sentence with no extraneous detail, front-loading the core action and resource.

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

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

No output schema is present, and the description does not mention return value or side effects. It could be more complete with a note on what it returns or what happens if the name already exists.

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

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

The input schema already includes descriptive text for all three parameters, and the tool description adds no extra parameter semantics, so the baseline of 3 applies.

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

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

States a specific verb 'Create' and a clear resource 'named profile', and clarifies it is an alias of session_new, effectively distinguishing it from related profile/session tools.

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

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

No explicit guidance on when to use this tool over session_new or other profile/session tools. The alias mention gives some hint of interchangeability, but lacks prerequisites or conditions.

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

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

No annotations are provided, so the description carries full behavioral disclosure. It states only the action ('Set the active profile') without describing whether it modifies global, per-session, or per-profile state or whether it has side effects on already-created sessions. It does not disclose the implications of changing the active profile.

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

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

A single, direct sentence with no filler. The parenthetical 'alias of session_use' demonstrates useful context without exploding length, front-loading the core action and important alias relationship.

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 minimal complexity and full schema coverage, the description is mostly sufficient to call the tool. However, it lacks the semantic context of what an 'active profile' affects—session targeting, default behavior, or interaction with session_use—making it incomplete for an agent without prior knowledge.

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?

Input schema covers 100% of parameter descriptions (name, lease, session), so a baseline of 3 applies. The description adds no explanation of the parameters beyond what the schema already provides, such as the meaning of 'lease' or session targeting.

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

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

The description identifies a clear verb-resource pair ('Set the active profile') and explicitly marks it as an alias of session_use, which helps differentiate it from profile_list, profile_new, etc. It does not fully explain the broader semantics of 'active profile', so it is slightly below a 5.

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

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

The description only states that it is an alias of session_use, but gives no guidance on when to use this tool over session_use or other profile tools. There is no mention of prerequisites, alternatives, or when it is appropriate to call it, leaving the agent without selection 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?

With no annotations provided, the description carries the full behavioral burden and does state the core operation. However, it does not disclose whether reload waits for page load, whether it may discard unsaved state, or how it behaves when the session is leased. It is adequate for a simple action but not rich.

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

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

The description is a single sentence with no filler words. It front-loads the action and resource immediately and earns its place entirely.

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

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

For a simple no-required-parameter tool with a fully documented schema, this description is sufficient. The agent knows the target and the two optional parameters are covered; since there is no output schema, no return-value explanation is needed.

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

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

Schema description coverage is 100%, so both optional parameters are already fully explained in the schema. The tool description adds no parameter-level information, so the baseline of 3 applies.

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

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

The description states a specific action ('Reload') and the exact resource ('current page'), making the tool's purpose immediately obvious. It does not explicitly contrast with siblings like 'back' or 'forward', but the action is distinct enough that the agent can tell it apart.

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

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

There is no guidance on when to use this tool rather than alternatives such as 'go', 'back', or 'forward'. The description relies entirely on the tool name and the user's intuition; no explicit when/when-not or sibling differentiation is provided.

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

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

Discloses detailed behavioral traits beyond the openWorldHint annotation: return formats per mode (image vs path vs tiles path/count), never-base64 guarantee, truncation markers (truncated, height_truncated, captured/total heights), and lease token threading (never read from server env). This is far richer than the bare annotation.

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?

Though about 200 words, every sentence serves a purpose. It front-loads the core purpose, branches into modes, and integrates usage guidance and truncation semantics without wasted words. Structure is logical and scannable.

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

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

Given 9 optional parameters and no output schema, the description covers all scenarios: image vs file vs tiles, disk output, truncation behavior, session uniqueness on shared daemons, and lease handling. Nothing an agent needs to call correctly is missing.

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

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

Even with 100% schema coverage, the description adds critical meaning: tiles implies full_page, max_tiles bounds output/disk not decode memory, max_screenshot_px bounds decode itself, and defaults come from environment variables (VIBATCHIUM_MAX_TILES, VIBATCHIUM_MAX_SCREENSHOT_PX). This goes well beyond the schema's per-parameter descriptions.

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

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

States 'Capture a screenshot' clearly as a verb+resource, then further specifies three modes (no path returns image, path saves PNG, tiles=true slices into tiles). It distinguishes itself from text-reading siblings by explicitly saying 'only screenshot when you actually need the pixels'.

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

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

Provides explicit usage direction: 'Prefer reading the page text/selectors first — only screenshot when you actually need the pixels.' Also advises using tiles for layout-heavy pages so a vision-capable caller reads tile-by-tile, leaving no ambiguity about when to choose this tool over alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool takes a screenshot with bounding-box overlays. It does not mention side effects (e.g., whether the page is modified), authentication requirements, rate limits, or what the output file actually contains beyond 'overlays'. For a tool that saves to a path, details about the file format or how overlays are rendered are missing. This is a significant gap given 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?

The description is a single sentence, highly concise, and front-loads the core purpose. Every word contributes: 'Screenshot' sets the action, 'with @eN bounding-box overlays' adds the distinguishing feature, and 'vision-LLM friendly' signals the intended use case. No fluff or repetition. It is an exemplary concise description.

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

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

The tool has moderate complexity (4 params, including session and lease), but the description provides only the bare essence. It lacks context on when to use this instead of plain 'screenshot' or vision tools, and it does not describe the nature of the @eN overlays or their format. There is no output schema, so the description should clarify what the agent can expect from the call, but it does not. An agent would need to infer too much.

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

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

The input schema covers 100% of parameters with descriptive text (path, lease, session, full_page). The description adds no additional parameter meaning beyond what the schema already provides. Per the calibration rule, when schema_coverage is high (80%+), the baseline is 3, and there is no extra value from the description to raise it.

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

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

The description clearly states the core function: 'Screenshot with @eN bounding-box overlays (vision-LLM friendly).' It specifies a verb ('Screenshot'), a resource (bounding-box overlays), and a distinguishing feature (vision-LLM friendly) that separates it from the plain 'screenshot' sibling. The purpose is unambiguous and specific.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. It does not mention plain 'screenshot', vision tools, or any exclusions. The parenthetical 'vision-LLM friendly' hints at a use case (preparing images for vision models) but does not state when to prefer it over other tools or when not to use it. This leaves an agent without clear direction.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states a high-level action. It does not disclose that scrolling may require a lease token, session behavior, or any side effects (e.g., whether scrolling affects the DOM or triggers events). This is a material gap given the complex parameter 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?

The description is a single, compact sentence with no filler. It front-loads the core purpose, making it quick to parse. It could benefit from a second sentence on usage, but as a concise statement it is well-structured.

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

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

For a tool with 5 optional parameters, no required fields, no output schema, and no annotations, the description is too thin. It fails to explain the purpose of lease/session parameters, when to use target vs. dx/dy, or any potential side effects. An agent would need to infer substantial context from parameter names alone, which 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?

The schema documents all 5 parameters with descriptions (100% coverage), so the description does not need to repeat them. The tool description adds only the notion of 'scroll into view' which maps to the target parameter, but it doesn't clarify the relationship between dx/dy and target. Since schema already covers parameter meaning, the baseline of 3 is appropriate.

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

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

The description clearly states the verb 'scroll' and the resource (page or target element), distinguishing it from navigation siblings like go/back/forward. It is specific enough to understand the primary action, though it doesn't mention the scroll mechanics (pixel offsets vs. into-view), so it loses a point for incompleteness.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., go, reload, or click for in-element scrolling). There are no exclusions or conditions mentioned, leaving the agent to infer usage purely 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.