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

With no annotations, the description carries the full burden, but 'Click element' only names the action. It does not disclose that clicking may trigger navigation, page changes, or side effects, nor does it mention waiting behavior, prerequisites, or result of the click. It supplies almost no behavioral context beyond the action itself.

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

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

The description is only two words, so it has no fluff, but it is under-specified rather than efficiently concise. It front-loads nothing of substance beyond repeating the tool name and object. A genuinely effective description would pack at least usage or behavioral guidance into the space.

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

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

For a browser interaction tool with five parameters, no annotations, and no output schema, this description is inadequate. The schema covers parameter names but not when to use the tool, what happens after the click, or how to handle clicks that cause navigation. It leaves the agent to guess important invocation 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?

With 80% schema description coverage, the schema already explains most parameters (ref, button, element, doubleClick). The description adds nothing about how parameters interact, but the high schema coverage means this is acceptable at baseline. It does not compensate for the one parameter without a description (modifiers), but the enum values provide some meaning.

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

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

The description states a clear verb ('Click') and resource ('element'), so an agent knows the tool performs a click action. However, it does not mention optional behaviors like double-click or button choice, and it does nothing to distinguish itself from sibling interaction tools like browser_hover, so it misses the specificity needed for 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 usage context is provided. The description does not state when clicking is appropriate versus hovering, typing, pressing a key, or filling a form, and it offers no alternatives or exclusions. An agent must infer usage 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. 'Get console messages' only restates the tool's name and offers no information about side effects, whether messages are cleared, whether this requires a loaded page, or what the returned messages look like.

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

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

The description is a single short phrase with no filler, and it front-loads the operation. It is not verbose, though it is somewhat under-specified; still, for a zero-parameter tool, this level of brevity 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?

There is no output schema and no annotation, so the description must compensate, but it only says 'Get console messages.' It does not explain return format, when the tool is appropriate, or how it relates to browser_navigate, browser_evaluate, or browser_network_requests. This is insufficient context for reliable agent decision-making.

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 is an empty object with zero parameters, so the schema already fully defines the parameter surface. With 0 params, the description need not add parameter semantics, and the baseline of 4 applies.

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

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

'Get console messages' states a clear verb and resource, and the resource is distinct from sibling tools like browser_network_requests and browser_snapshot. It does not explicitly differentiate itself from potential alternatives such as browser_evaluate, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus sibling browser tools, no exclusions, and no context such as 'use after navigation' or 'use when debugging.' The only implied usage is the tautological 'get console messages when you need console messages,' which is not actionable.

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 bears the full burden of disclosing behavior. It does not mention whether this performs a single composed gesture, whether the drop triggers events, whether the browser waits for transitions, or what side effects may occur. The description simply restates the action without adding meaningful behavioral 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?

The description is concise and front-loaded with the core action, with no filler words. However, it is under-specified rather than usefully concise: key aspects like the start/end element relationship, reference semantics, and behavior are missing, making the brevity less helpful than it could be.

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

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

Given that this is an interactive browser tool with four required parameters, no annotations, and no output schema, the description is far too minimal. An agent would not know from the description how to structure the drag operation, what qualifies as a valid start or end element, or what outcome to expect, so the contextual information is incomplete.

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

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

The input schema already describes all four parameters with basic labels such as 'Start element description', 'Start element reference', and their end counterparts, so schema coverage is 100%. The tool description adds no additional parameter meaning, such as how descriptions and references should be paired or what format is expected, 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 clear verb action ('drag and drop') and a resource ('element'), which identifies the tool's basic purpose and distinguishes it from sibling tools like click, hover, and type. However, it is still quite terse and does not indicate that the operation involves both a start element and an end element, so it lacks specificity about the drag relationship.

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 about when to use this tool versus alternatives such as browser_click, browser_hover, or browser_evaluate. The appropriate use case is only vaguely implied by the phrase 'drag and drop' and no exclusions, prerequisites, or fallback guidance are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions that execution happens 'in page context' and that the result is returned, but it fails to disclose potential side effects (e.g., page mutation), support for async expressions, error behavior, or result serialization limits. For arbitrary JS execution, this is a significant gap.

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

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

The description is two sentences with no redundant filler. It front-loads the core purpose, then immediately provides the two accepted input forms. Every sentence adds value and there is no wasted text.

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

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

Although the tool has only one parameter and no output schema, the description does not explain important execution details: whether promises are awaited, how complex return values are serialized, whether the code can modify the page, or how errors are surfaced. For a JS evaluation tool with no annotations, this leaves an agent uncertain about critical behavior.

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

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

The schema description already covers the 'function' parameter thoroughly, including examples of both function and expression forms, giving 100% schema coverage. The tool description repeats that same information and adds little beyond the schema, 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 uses a specific verb and resource: 'Execute JavaScript in page context.' It clearly distinguishes itself from all sibling browser tools, which handle navigation, clicks, screenshots, etc., so an agent can immediately tell this is the tool for running JS in the page.

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

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

The description implies that this tool is for executing JavaScript, but it does not explicitly state when to use it over alternatives like browser_snapshot or browser_console_messages. It provides no when-not-to-use guidance or prerequisites, relying on the reader to infer the use case.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'fill' without revealing whether the tool submits the form, clears existing values, dispatches events, waits for navigation, or has any side effects. This is a significant gap for a mutating browser action.

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

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

A single, efficient sentence with no filler words. The core action and scope are front-loaded, making it easy to scan.

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

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

For a browser automation tool with no annotations and no output schema, the description is too thin. It doesn't mention prerequisites (e.g., must be on a page with a form), return values, error cases, or whether the operation is atomic. An agent lacks enough context to invoke it reliably.

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

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

Schema description coverage is 100%, so the schema already documents each property thoroughly. The description adds only a high-level 'multiple form fields at once' statement and no extra detail beyond the schema, which meets the baseline but doesn't elevate it.

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

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

The description uses a specific verb ('fill') and resource ('multiple form fields at once'), clearly distinguishing it from sibling tools like browser_type (single field) and browser_select_option (single dropdown). An agent can immediately tell this is a batch operation for form inputs.

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 'at once' implies batch usage, contrasting with single-field siblings, but there is no explicit guidance on when to choose this over browser_type or how it differs in behavior. The usage context is implied rather than stated.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior, but it only restates the action in four words. It does not mention side effects like CSS hover states or UI changes, failure conditions, or whether the pointer remains positioned afterward.

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 free of fluff, but it is more under-specified than concise, providing only a single sentence that states the action. It is usable but lacks the richness expected for a browser automation 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 2-parameter browser tool with no annotations and no output schema, this description is insufficient: it does not explain how to identify the element, when hovering is appropriate, or what observable effect the hover produces. An agent must infer these details from parameter names or sibling context.

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

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

Schema description coverage is 100%, so the baseline is 3; however, the schema descriptions ('Element reference', 'Element description') are thin, and the tool description adds no clarification on how to populate or relate the parameters.

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, 'Hover over element', with a specific verb and resource. It does not explicitly contrast with sibling tools like browser_click or browser_drag, but 'hover' is a distinct operation, so the purpose is apparent.

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 hover versus click, drag, or other sibling tools. It does not mention typical use cases such as revealing tooltips or hover states, nor any exclusions or 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. 'Navigate to URL' discloses only the core action — it does not state whether the tool waits for page load, navigates in the current tab, how navigation failures are surfaced, or what happens to page state. For a state-changing browser operation, this is a significant transparency gap.

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

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

Three words with zero waste, so it is structurally clean and fully front-loaded. But it crosses into under-specification: there is no substance to structure, and it resembles the terse 'Process' pattern the rubric penalizes. Conciseness is achieved at the expense of utility.

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

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

The tool is low-complexity with only one well-documented parameter, but it is a state-changing browser operation with no annotations and no output schema. The description fails to address what an agent should expect after calling it — load waiting, snapshot staleness, or failure behavior — leaving the invocation context 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 the url parameter is documented as 'URL to navigate to,' so the schema already carries the parameter weight. The tool description 'Navigate to URL' adds no semantics beyond that, which matches the baseline 3 for high 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 verb and object — 'Navigate to URL' — so an agent can tell the tool performs navigation. However, it is only one step removed from a tautology of the tool name, adds the parameter name as the object, and does nothing to differentiate it from siblings like browser_navigate_back or browser_tabs. The purpose is minimally clear but not genuinely informative.

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 zero guidance on when to use this tool versus its 16 siblings. It does not mention that browser_navigate_back handles history navigation, that browser_snapshot should follow navigation to inspect the result, or any prerequisites or exclusions. An agent is left to infer context entirely from the tool name and sibling list.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It clearly indicates the main side effect of changing the current page to the previous one, but it does not describe edge-case behavior such as what happens when no previous page exists or whether navigation waits for page load.

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 filler or redundancy. It front-loads the action and object clearly, making it easy for an agent to parse quickly.

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

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

Given the tool's low complexity, zero parameters, and no output schema, the description covers the essential invocation context. It could mention error handling or edge cases, but those are not critical for basic 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?

The tool accepts zero parameters, so there is nothing to document beyond what the schema already conveys. A baseline score of 4 is appropriate when no parameters exist and the schema is trivial.

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 phrase, 'Navigate back', and a clear object, 'previous page'. It directly distinguishes the tool from the sibling browser_navigate, which presumably goes to a specific URL or forward.

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: after the user has navigated away and needs to return to the prior page. However, it does not explicitly state when not to use it or mention alternatives such as browser_navigate for explicit URL navigation.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. 'Get network requests' only implies a read operation and does not explain whether it covers the current page, all tabs, or a session, nor how results are returned or whether any state is affected.

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

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

The description is maximally concise and front-loaded, with no filler or redundant detail. It is terse, but for the amount of content provided, every word is used 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?

With no annotations, output schema, or parameters, this description is the only source of context. A three-word phrase does not adequately specify what 'network requests' means in this browser context, what the agent should expect as a result, or how the tool relates to sibling browser tools.

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

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

The tool has zero parameters and the schema is an empty object, so schema coverage is 100%. With no inputs to document, the baseline of 4 applies; the description does not need to add parameter meaning.

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

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

The description states the action 'Get' and the resource 'network requests', which is a clear verb+resource pairing. However, it is nearly identical to the tool name, lacks scope (e.g., current page, all tabs, session), and does not explicitly differentiate itself from sibling browser diagnostic 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?

There is no guidance on when to use this tool instead of browser_console_messages or browser_snapshot. No conditions, prerequisites, or exclusions are provided, leaving the agent to infer appropriate usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure and states only the literal action. It fails to disclose that pressing a key can trigger side effects (e.g., Enter submitting forms, Escape closing dialogs), whether the event targets the focused element, or what the tool returns.

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 four-word description has zero wasted words and is appropriately sized for a single-parameter tool. 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?

Despite being a simple one-parameter tool, the description omits selection-critical context: when to choose this over browser_type, whether the key activates the focused element or the page, and what observable effects to expect after the press. The large 16-tool sibling set increases the risk of confusion.

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% — the key parameter is already documented with examples (Enter, Escape, Tab). The description adds nothing beyond what the schema provides, 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 clear verb and resource ('Press keyboard key'), which identifies the core action unambiguously. However, it does not differentiate from siblings like browser_type (text input) or browser_click, leaving the distinction between pressing a key and typing text implicit.

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. The description does not mention that browser_type is for entering text, whether the press targets the focused element, or whether this is appropriate for shortcuts and navigation keys.

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 disclosing behavior. It only states the primary action and does not mention side effects such as viewport changes, page reloads, or responsive-layout impacts. The agent is left to infer the operational 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?

The description is extremely concise at six words with no filler or repetition. It is easy to scan and front-loads the action and target resource, though it sacrifices behavioral detail for brevity.

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 two-parameter tool, the schema covers the inputs and the description names the target resource. However, with no annotations and no output schema, the description does not fully convey the tool's scope or side effects, making it minimally viable but not fully self-sufficient.

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 documents both parameters with descriptions and pixel units, so schema coverage is 100%. The tool description adds no parameter meaning beyond what the schema provides, which is acceptable given the schema's completeness.

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

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

The description clearly states a specific verb and resource: resize the browser window. It is distinct from the sibling browser tools, which focus on navigation, input, and inspection, so an agent can recognize the intended operation. It stops short of clarifying whether the viewport or the entire OS window is resized, but the core 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 provides no guidance on when to use this tool or when an alternative would be more appropriate. The intended use is implied by the name, but no context, prerequisites, or exclusions are given.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It only states the action without detailing behavior such as handling of multi-select, whether previous selections are cleared, or whether the dropdown must be visible/interactive. This is a significant transparency gap.

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

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

The description is a single, direct sentence with no filler. It communicates the core purpose efficiently and front-loads the verb and object.

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

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

The tool is simple and all three parameters are described in the schema. However, with no annotations and no usage guidance, the description leaves gaps around when to use it and what observable effects to expect, making it minimally viable but not fully complete.

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

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

Schema description coverage is 100%, so the input schema already documents what each parameter means. The tool description adds no additional meaning beyond the schema, but the schema is sufficient, so the baseline score 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 ('Select') and resource ('dropdown'), making the tool's function immediately clear. It is distinct from sibling tools like browser_click or browser_type, though it does not explicitly differentiate itself from alternatives.

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

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

There is no guidance on when to use this tool versus alternative browser interaction tools like browser_click, browser_type, or browser_fill_form. The usage context is only implied by the tool's name and description rather than stated.

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

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

There are no annotations, so the description carries the full burden of disclosing behavior. It does not state whether the operation is read-only, what the return value looks like, whether it is blocking, or what the accessibility snapshot contains. 'Capture' hints at non-mutating behavior but does not confirm it.

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 phrasing. It is front-loaded 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?

Given no annotations, no output schema, and no parameter structure to rely on, the description leaves too much unspecified. An agent cannot predict the return format, whether the page is modified, or exactly what information the accessibility snapshot will provide. It is sufficient for initial selection but not for confident invocation.

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

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

The tool has zero parameters and schema coverage is 100%, so there is nothing for the description to add about parameter meaning. Per the baseline for a no-parameter tool, this is adequate.

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 ('Capture') and names a clear resource ('page accessibility snapshot'). It is distinguishable from browser_take_screenshot by the 'accessibility' qualifier, though it does not explicitly state what the snapshot contains or how it differs beyond that word.

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 about when to use this tool versus alternatives like browser_take_screenshot or browser_evaluate. The intended use case is only implied by the phrase 'accessibility snapshot', not stated explicitly.

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 must carry the full burden of disclosing behavior. It does not state that closing tabs is destructive, that selecting changes the active tab, that new opens a blank tab, or what list returns. The description is behaviorally 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 short, but shortness here is under-specification rather than effective conciseness. It conveys almost no operational information and does not earn its place.

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

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

With no annotations, no output schema, and a multi-action tool, the description is critically incomplete. An agent cannot determine return behavior, side effects, or preconditions, and the tool is not distinguishable from its many siblings based on this description.

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 fully documents both parameters, including the action enum and the index description, so the schema covers the semantic baseline. However, the description itself adds no 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 'Manage browser tabs' is essentially a restatement of the tool name and provides no specific verb or scope. It does not mention the distinct actions (list, new, close, select) or how this tool differs from browser navigation or snapshot 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?

There is no guidance on when to use this tool versus browser_navigate, browser_snapshot, or other sibling tools. The description gives no context about tab management being the right choice for opening, closing, switching, or listing 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?

Annotations are absent, so the description carries the full burden of behavioral disclosure. It only states the action and does not explain whether the screenshot is returned as data, saved to a file using 'filename', or how 'fullPage' affects capture. There is no mention of side effects, output format, or element selection semantics.

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

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

The description is concise and front-loaded with no wasted words, which is good. However, it is so minimal that it sacrifices useful context, making it more under-specified than appropriately concise.

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

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

For a tool with five parameters, no annotations, and no output schema, the description is insufficient. It does not explain what the tool returns, whether it saves a file, how to target an element versus a page, or how the sibling browser_snapshot relates to it. An agent would need to open the schema and guess at behavioral details.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal semantic value by indicating that capture can target 'page or element', which loosely maps to 'fullPage' and 'element'/'ref', but it does not clarify the relationship between 'ref' and 'element' or how 'filename' is used.

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, 'Take screenshot of page or element', which clearly identifies the tool's function. It is distinct from all sibling browser tools, none of which perform screenshot capture.

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 about when to use this tool versus alternatives. Notably, browser_snapshot could be confused with it, but the description does not explain that screenshots are for visual capture while snapshots are for accessibility/DOM state. The intended use context is only implied by the name and 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 must carry behavioral disclosure, but it only states the literal action. It does not say whether existing element text is replaced or appended, whether the element must already be focused, or what happens when 'submit' is true. There is no contradiction with annotations because none exist.

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

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

The description is extremely concise and front-loaded with the core action and target. It contains no filler, though its brevity means some behavioral nuance is sacrificed; it is efficient rather than bloated.

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 fully documented parameters, the minimal description is somewhat usable. However, with no annotations, no output schema, and no guidance on behavior or alternatives, the description leaves important context undisclosed for an agent to call it well.

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

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

Schema description coverage is 100%, so the parameters are already self-explanatory in the schema. The description adds no extra semantic detail about parameters, but the baseline score of 3 is appropriate because the schema carries the load.

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 (type) and target (text into element), so an agent understands the basic operation. It is differentiated from navigation, screenshots, and clicking, though it does not explicitly distinguish itself from sibling input tools like browser_fill_form or browser_press_key.

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

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

There is no guidance about when to use this tool instead of alternatives. The description does not mention that browser_fill_form may be better for form-like interactions or that browser_press_key handles key presses, so the agent is left without routing information.

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, and 'Wait for condition' discloses nothing: no blocking semantics, no timeout behavior, no error handling when the condition is never met, and no polling explanation. An agent cannot predict what happens when time and text are combined or when no parameters are supplied.

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 words is under-specification rather than conciseness. The single sentence fragment does not earn its place because it conveys no actionable information beyond what the tool name already implies.

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 three optional parameters, no output schema, and no annotations, the description should clarify behavior with no arguments, how time interacts with text/textGone, and timeout/failure semantics. All of this is absent, leaving a browser automation agent unable to call the tool reliably or interpret its result.

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

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

Schema description coverage is 100%, so each parameter is individually documented in the schema, which sets the baseline at 3. The description adds no parameter-level meaning beyond what the schema already provides, but it also does not need to compensate for any schema gaps.

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

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

The description 'Wait for condition' is nearly a restatement of the tool name and adds no specificity about what conditions are supported. The schema reveals three distinct condition types (text appearance, text disappearance, fixed time), but the description leaves all of that implicit. It sits just above a pure tautology because it introduces the vague notion of a 'condition'.

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 this tool versus alternatives like browser_snapshot (for manual polling) or browser_evaluate (for custom wait logic). There is no mention of expected context, exclusions, or conditions under which a sibling tool would be preferable.

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