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

No annotations exist, so the description carries the full burden. It usefully discloses an unusual side effect, the on-page cursor being shown first, but says nothing about failure behavior when no element matches, whether it scrolls into view, whether it waits for the element, or whether clicking may navigate the page.

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

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

Two short sentences with the core action front-loaded and the secondary visual behavior trailing. Nothing is redundant or padded.

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

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

For a two-parameter tool with no output schema, the definition covers the action and addressing modes adequately. The remaining gap is what an agent should expect afterwards, such as a returned snapshot, navigation, or an error, which is a moderate omission for a browser automation step.

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

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

Schema description coverage is only 50%, and the description compensates for the undocumented 'selector' parameter by explaining it accepts either a CSS selector or exact visible text, which is essential and absent from the schema. The 'label' parameter is documented in the schema itself, so the gap is covered.

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 (click) and target (an element), and specifies the two accepted addressing modes, CSS selector or exact visible text. This is enough to distinguish it from browser_type or browser_scroll among siblings, though no sibling is named explicitly.

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

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

The description implies when to use it (targeting an element by selector or visible text) but gives no explicit when-not conditions, prerequisites, or alternatives such as browser_type for text entry or browser_press_key for keyboard actions.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that this is a powerful escape hatch and returns a value, but says nothing about side effects on page state, execution context, async/promise handling, error behavior, or security implications of arbitrary JS execution.

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

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

Two tight sentences with the core behavior front-loaded and the usage caveat second. 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?

For an arbitrary JavaScript evaluation tool with no annotations, no output schema, and an undocumented parameter, the description is too thin. An agent lacks guidance on execution context, result serialization, and failure modes.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that the required 'expression' parameter is JavaScript, but provides no details about expression scope, async handling, serialization of return values, or what happens with non-serializable results.

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: run JavaScript in the target tab and return the value. It also distinguishes itself from the many specific browser_* siblings by framing itself as a 'powerful escape hatch' and directing callers to prefer specific 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?

Provides a clear usage principle: use this only when specific tools do not fit. It does not name which siblings are preferable in which situations, but the general routing guidance is explicit.

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

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

With no annotations, the description carries the burden and does disclose key behavior: it creates a tab group and redirects later calls to it. However, it omits failure behavior, whether an existing active group is replaced, permissions, and what is returned.

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

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

Two short sentences, front-loaded with the action and immediately followed by the scoping rule. There is no wasted wording.

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

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

For a no-annotation, no-output-schema mutation tool, the description covers the essential action and subsequent-call targeting clearly. It leaves some lifecycle details unstated, such as behavior when a group already exists or how the group is later ended.

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 title, url, and color. The description reinforces that the group is named and becomes the target, but adds no parameter-level detail beyond the schema.

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

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

The description states a specific verb and resource: create a named Chrome tab group. It also explains scope, making the group the target for every later call, which distinguishes it from siblings like browser_group_end and browser_groups.

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 clear usage context: "Start a task" and "One group per task," implying it should be called at task beginning. It does not explicitly name when not to use it or compare it to browser_group_end, so it stops short of full alternative 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?

With no annotations provided, the description carries the full behavioral burden. It usefully discloses that tabs stay open by default and only close when closeTabs=true, but it omits whether the group is deleted, whether groupId is required, and what happens if the group does not 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?

Two short sentences with no wasted language. The action is front-loaded and the important default behavior about tabs is stated directly afterward.

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 with no annotations or output schema, the description covers the core purpose and the most important default. It is still incomplete because groupId semantics and the group's lifecycle after ending are not explained.

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

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

Schema description coverage is 0%, so the description must compensate. It explains closeTabs clearly, but groupId is only indirectly referenced as 'its group' and is not described as optional or defaulting to the active group, leaving half the parameters under-specified.

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 and scope: finishing the current task and stopping targeting its group. The sibling browser_group_begin makes the begin/end pairing inferable, but the description does not explicitly name or differentiate against that 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?

It gives implied usage with 'Finish the current task', which tells the agent when this tool is appropriate. However, it does not state when not to use it, what happens if no group is active, or explicitly route to browser_group_begin for the opposite 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, so the description must carry the behavioral load. It implies a pure read with no mutation, which is useful, but it doesn't say whether it returns group ids/names, whether empty groups appear, or whether the current-group marker is null when none is active. Output behavior is left entirely unstated.

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 of about fifteen words, no filler, with the most decision-relevant detail (which group this agent is working in) at the end of the clause.

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

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

For a trivial no-param read this is close to adequate, but with no annotations and no output schema, the description leaves the return shape unknown — an agent can't tell if it gets group names, ids, or just a count. One more clause on return contents would make it 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?

Zero parameters, so baseline is 4; the description correctly signals a no-argument call. Nothing more is required here.

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

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

Specific verb (list) plus resource (tab groups) with added scope detail: it also reports which group the agent is currently active in. Distinguishes clearly from browser_tabs (tabs) and browser_group_begin/end (group lifecycle).

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?

An agent can infer this is a read-only inspection call, and the mention of 'currently working in' implies it's useful before starting grouped work. But it never names the alternative (e.g., browser_tabs for flat tab lists) or says when not to use it.

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

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

No annotations, so the description carries the full burden. It discloses that output is truncated, which is a useful behavioral trait, and 'Read' implies a non-mutating operation. But it never defines what 'the target tab' means (active tab? last opened?), nor says anything about permissions or the shape of the returned HTML.

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

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

Two short sentences, zero filler, with the core action front-loaded before the usage hint. Nothing is 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 one-optional-param read tool with no output schema, this is close to adequate, but it leaves the tab-targeting semantics and the truncation behavior (silent cut vs. marker) unstated, which matters for an agent deciding whether to raise the limit.

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

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

The single parameter has 100% schema coverage, so the schema already explains 'limit' as max characters with a 20000 default. The description only echoes the truncation idea and adds no format or interaction detail (e.g., whether truncation is silent or marked).

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

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

States a specific verb and resource: 'Read the raw HTML of the target tab', with the truncation caveat. It is clearly distinguishable from browser_text and browser_snapshot by the word 'raw HTML', though it does not name those siblings directly.

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

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

'Use when text is not enough' gives a concrete selection condition that implicitly routes the agent away from browser_text. It stops short of naming the alternative tool or stating when not to use it (e.g., for structured element lookup, use browser_snapshot).

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

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

With no annotations, the description carries the full burden, and it does disclose one important behavior: the call blocks until load completes, and it targets the task tab with an active-tab fallback. It says nothing about timeout behavior, navigation failure, or whether it can leave the page in a partially loaded 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?

One sentence, front-loaded with the action and target, with the blocking behavior appended as a qualifier. Nothing extraneous.

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

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

For a one-parameter navigation tool with no output schema and no annotations, the description covers the essentials: what it navigates, which tab, and that it waits for load. Only failure/timeout semantics are missing, which is a minor gap at 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 coverage is 0% and the single parameter has no description in the schema, so the description must compensate. It does connect the one parameter to a URL concept, but adds no meaning about accepted schemes, absolute vs relative URLs, or what happens with redirects — leaving the format underspecified.

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

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

States a specific verb+resource ('Navigate ... tab ... to a URL') and scopes the target as the task tab or active tab, which distinguishes it from browser_tab_new and browser_tab_select. It is clear what the tool does, though it never names the sibling navigation-adjacent tools it supersedes.

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

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

Usage is only implied: an agent can infer this is the tool for loading a page, and that tab creation/selection belongs to browser_tab_new/browser_tab_select. There is no explicit statement of when to use it, when not to, or that a tab fallback exists only when no task tab is present.

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

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

With no annotations, the description carries the full behavioral burden and mostly fails it: it does not say whether the key fires default browser actions (e.g. Enter submitting a form), which element receives the event, what happens if no tab is active, or whether the operation can be undone. Only the vague 'target tab' scoping 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?

One front-loaded sentence with no filler; the action comes first and the key examples follow. It is efficient, though the brevity is partly the source of the missing usage and behavioral context.

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

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

For a single-parameter tool with no output schema, the description covers the basic action and key vocabulary. But it leaves the 'target tab' concept and event-delivery semantics unexplained, which are the details an agent would need to call it reliably.

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

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

Schema coverage is 0%, so the description must supply the value domain — and it does, listing Enter, Tab, Escape, ArrowUp/Down, Backspace, 'or any key name'. That is genuinely useful beyond the bare string schema, but it omits key-name format details (KeyboardEvent.key vs code, case sensitivity, modifier combinations like 'Control+A').

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: 'Send a key press to the target tab', which is clearly a keyboard-input action distinct from browser_type (text entry) or browser_click. It does not explicitly name or contrast with those siblings, and 'target tab' is left undefined, 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 lists example keys but never says when to use this tool versus browser_type or browser_click, nor what preconditions apply (focused tab, focused element). An agent must infer all usage context from the examples.

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

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

With no annotations, the description carries the burden: 'use sparingly' hints at cost but never quantifies it, and it doesn't say whether the capture is of the viewport by default, whether it includes chrome/overlays, or what permissions are needed. The scoping to 'the target tab' is the one useful behavioral fact added.

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

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

Two short sentences, zero filler, with the core capability front-loaded and the usage caution second.

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

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

A screenshot tool is conceptually simple and the return type is self-evident from 'PNG screenshot', so no output schema is needed. But the sole parameter is undocumented and the cost/permission profile is only hinted at, leaving real gaps for a no-annotation tool.

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

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

Schema coverage is 0% for the single fullPage boolean and the description never mentions it, so an agent gets no guidance on what turning fullPage on actually changes or when to use it. This is exactly the case where the description should compensate and doesn't.

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 the concrete output (PNG screenshot) and target (the target tab), which immediately distinguishes it from text-oriented siblings. It does not spell out a verb but 'screenshot' plus 'target tab' 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?

Explicitly warns to use it sparingly and names two alternatives (snapshot, text) plus the condition that selects them (locating elements). It stops short of saying when a screenshot IS the right choice, such as visual layout verification.

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 behavioral burden, yet it says nothing about waiting for lazy-loaded content, behavior at page top/bottom, whether it is a no-op at boundaries, or what the call returns. Only the granularity of movement (one viewport per page) 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?

A single front-loaded sentence with zero filler; the unit of measurement is the one piece of information an agent needs first.

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

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

For a one-optional-parameter tool this is minimally adequate, but with no annotations and no output schema, the description should say which tab is targeted and whether a return value indicates new content or position.

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 sign convention ('Positive scrolls down, negative up') is already documented. The description adds the unit semantics – a page equals a viewport height – which is genuinely beyond the schema, but nothing about fractional values or defaults.

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 ('Scroll the target tab') with a clear unit of movement ('whole viewport pages'). It is distinguishable from click/type/snapshot siblings, though 'target tab' is not defined relative to the tab-selection 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?

Usage is only implied by the verb; there is no statement of when to scroll versus calling browser_text/snapshot to fetch content, nor of prerequisites such as which tab must be active. The phrase 'target tab' hints at tab context but does not route 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?

With no annotations, the description carries the full burden; it does disclose the return form (accessibility tree rendered as text) and that it targets the active tab, which is the key behavioral fact. It says nothing about output size, whether element references are included for clicking/typing, or any truncation/pagination 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?

Two short sentences, front-loaded with what the tool returns and followed by when it is best used. No filler.

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

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

For a no-param, no-annotation, no-output-schema tool the description covers the essentials of purpose and return format, but omits how elements are identified in the tree (which matters because it is recommended for locating click/type targets) and any size or truncation caveats.

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

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

The tool takes zero parameters, so there is no parameter semantics for the description to explain. Baseline of 4 applies; the description correctly implies no arguments are 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?

States a specific resource (accessibility tree of the target tab) and output form (as text). The term 'accessibility tree' distinguishes it implicitly from browser_html, browser_text and browser_screenshot, though no sibling is named explicitly.

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

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

'Best for locating elements to click or type into' gives an implied usage context, but there are no explicit exclusions or named alternatives among the many close siblings (browser_html, browser_text, browser_screenshot). An agent must infer when to prefer those over this.

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

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

With no annotations, the description carries the burden and does disclose the two things reported back: connection state and loaded extension version. It stops short of saying what a failed/disconnected result looks like or whether it errors versus returns a status, but it is a zero-parameter read-only probe with little hidden risk.

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 filler, with the primary purpose front-loaded and the usage trigger immediately after. Nothing could be removed without losing information.

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

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

For a trivial zero-arg diagnostic with no output schema, the description covers both what it checks and when to reach for it. The only gap is the shape of a negative result (disconnected bridge), which matters when the stated use case is triaging failures.

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

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

The tool takes no parameters at all, which is the baseline-4 case. The description correctly implies no inputs are needed by framing it as a simple status check.

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 object: checks whether the Chrome bridge is connected and which extension version is loaded. This is clearly distinguishable from all the action-oriented browser_* siblings, which manipulate tabs, DOM, or screenshots.

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

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

"Use this first when another browser tool fails" gives an explicit trigger condition, which is unusually actionable for a diagnostic tool. It doesn't state when not to use it (e.g. don't poll it routinely), but the primary routing guidance is present.

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

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

With no annotations, the description carries the full burden. It does disclose a genuinely useful behavioral trait — the no-argument fallback to the task tab — but omits whether closing is irreversible, what happens to unsaved state, and how an invalid id or index is reported.

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

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

Two short sentences, zero padding, and the primary action plus the important default are both front-loaded.

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

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

For a two-optional-param tool with no annotations and no output schema, the definition covers the main path and the default, but leaves the id/index selection conflict and index origin ambiguous — the exact details an agent needs to call it correctly every time.

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

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

Schema coverage is 0%, so the description must compensate. It establishes that id and index are alternative (and optional) selectors, which is real added meaning, but it never explains tab id provenance, index base (0- vs 1-based), or which wins if both are supplied.

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

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

States a specific verb and resource ("Close a tab") plus the two selectors, and adds the zero-argument default. It is clearly distinct from siblings like browser_tab_new or browser_tab_select, though it never names those alternatives explicitly.

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

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

"Without arguments closes the task tab" gives one concrete usage case, but there is no guidance on choosing between id and index, no statement of when to prefer browser_tab_select, and no note about what happens if the target tab is the only one or is in active use.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does reveal one non-obvious behavior — the tab is auto-assigned to the active task group — but omits whether the tab becomes focused, what happens with no active group, and whether the tool returns a tab handle.

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

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

Two short sentences with no filler, and the core action is front-loaded. It is efficient but arguably under-specified rather than tight.

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

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

For a tool with no annotations and no output schema, the description should say what the call returns (e.g., a tab identifier) so the agent can chain it to browser_tab_select or browser_text. That and the optional-parameter behavior are both missing.

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

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

Schema description coverage is 0% for the single optional 'url' parameter, so the description must compensate and does not. It never says that url may be omitted to create a blank tab, nor what happens when a url is supplied (navigation vs. preload).

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

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

States a specific verb and resource ('Open a new tab'), which is unambiguous on its own. However, it does not differentiate itself from the sibling browser_open, leaving the agent to guess which one creates a tab versus a window/navigation.

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

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

No guidance on when to use this versus browser_open, browser_tab_select, or browser_group_begin. The second sentence describes a side effect (joining the active task group), not a usage condition or prerequisite.

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. It implies a read-only listing, but does not say whether listing activates/selects tabs, whether results are paginated or capped, or what identifiers the returned tabs carry for follow-up calls like browser_tab_select.

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

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

Two short sentences with the core behavior front-loaded and the parameter variant second; no wasted 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 simple one-parameter listing tool with no output schema, the description is only partially complete: it never indicates what a tab entry contains (ids, titles, group names) that an agent needs to chain into browser_tab_select or browser_tab_close.

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

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

Schema coverage is 0%, so the description must explain the single parameter, and it does: groupOnly=true restricts results to the active task group. The boolean's false/default behavior is only implied, so it falls short of a 5.

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

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

States a specific verb and resource ("List open tabs") and adds scope detail about tab groups. It doesn't explicitly distinguish itself from the sibling browser_groups or browser_status, so an agent must infer the boundary.

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 groupOnly=true variant implies a use case (focusing on the active task group), but there is no explicit guidance on when to prefer this over browser_groups or browser_status, nor any exclusions.

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

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

With no annotations, the description carries the full behavioral burden. It says the tab is activated but does not disclose what activation changes (focus, foregrounding), what happens with an invalid id/index, or whether this has 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?

The description is a single front-loaded sentence with no wasted words. Its brevity is appropriate, though it leaves key details to inference.

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, no output schema, and two undocumented parameters, the description is too thin. It omits return behavior, error cases, and the semantics of selecting by id versus index.

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

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

Schema description coverage is 0%, so the description must compensate. It names id and index and indicates they are alternatives, but does not explain index base, valid ranges, optionality, or precedence when both are supplied.

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

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

The description states a specific verb and resource: activate a tab, by id or by index, sourced from browser_tabs. This clearly distinguishes it from browser_tab_new and browser_tab_close, though it does not explicitly name those siblings.

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

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

The phrase 'from browser_tabs' implies the tab list should be obtained first, but there is no explicit when-to-use guidance, prerequisite statement, or guidance on choosing id versus index.

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

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

No annotations are provided, so the description carries the full burden. It does convey a key behavioral trait — only *visible* text is returned, excluding hidden DOM/scripts — and hints at cost. But it never clarifies what 'the target tab' means (active tab? last selected?) and says nothing about truncation behavior or return type.

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

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

Two short sentences, front-loaded with the operation and followed by the selection rationale. No waste, though the unsupported superlative 'cheapest' is more marketing than specification.

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

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

For a simple one-param read tool this is nearly adequate, but with no output schema the description should state what comes back (a plain-text string, truncated at `limit`) and how the target tab is resolved. Those are real gaps for calling it correctly.

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

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

Schema description coverage is 100% and the single `limit` parameter is documented as 'Max characters, default 6000.' The description adds nothing about it, but with full schema coverage 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?

States a specific verb and resource: 'Read the visible text of the target tab.' The qualifier 'visible text' distinguishes it somewhat from sibling tools like browser_html (markup) and browser_screenshot (pixels). However, it never names those siblings, so an agent must infer the boundary itself.

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

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

'Cheapest way to understand a page' gives an implicit preference signal for page comprehension, but there are no explicit when-to-use/when-not-to-use rules and no named alternatives (e.g., use browser_html for structure, browser_snapshot for accessibility tree). The agent is left to infer selection logic.

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

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

No annotations are provided, so the description carries the full behavior burden. It does disclose one genuinely useful trait — that it dispatches input/change events, which matters for framework-bound inputs — but says nothing about whether existing content is replaced or appended, whether the element is focused, or what happens when the selector matches nothing.

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 tight sentence with no filler, and the mechanism plus the event-firing behavior are front-loaded. Nothing is redundant, though it is arguably too terse given the unexplained third parameter.

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

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

For a mutating browser tool with no annotations and no output schema, the definition covers intent but omits error behavior, return value (does it report success or the element state?), and any preconditions such as element visibility or frame context. Adequate to attempt a call, not adequate to predict outcomes.

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

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

Schema description coverage is 0% for all three parameters. The description implies 'selector' (CSS selector) and 'text' (the value), but the optional 'label' parameter is completely unexplained in both schema and description, leaving an agent to guess whether it is a fallback locator or a logging label.

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

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

States a specific verb ('Set the value') and resource ('an input/textarea'), with the mechanism named (CSS selector) and a behavioral detail (fires input/change events). It is clearly distinct from browser_click or browser_eval, though it never names a sibling explicitly.

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

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

Usage is implied: use this to populate form fields rather than typing keystroke-by-keystroke with browser_press_key. There is no explicit when-not guidance (e.g. contenteditable elements, rich text editors, or fallback to browser_eval when events don't register).

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

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

With no annotations, the description carries the full behavioral burden and falls short. It doesn't say whether existing selections are replaced or appended, whether a change/input event fires, whether upload completion is awaited, or what happens if the selector matches a non-file-input element. The plural 'files' versus the single filePath parameter is also unexplained.

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 verb and action, zero filler. Nothing to trim.

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

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

A two-parameter mutation-style tool with no annotations, no output schema, and undocumented parameters needs more than a single clause. Key agent-facing facts — error behavior on bad selectors, whether the file must exist and be reachable by the browser, and post-upload timing — are all missing.

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

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

Schema coverage is 0%, so the description must compensate and only partly does: 'local files' implies filePath is an on-disk path, and 'CSS selector' labels the selector parameter. It adds nothing on path format (absolute vs relative), existence requirements, or how files map to the single filePath field.

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 ('Attach') and resource ('local files to a file input'), which clearly separates it from browser_type and browser_click in the sibling list. It doesn't name a sibling explicitly, but the file-input framing makes the division of labor obvious.

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

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

Usage is only implied: the mention of 'a file input identified by CSS selector' hints that the target must be a file input rather than a generic element. There is no statement of when to prefer this over browser_type/browser_click, no preconditions (e.g., page loaded, input visible), and no exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses default behavior: the overlay is enabled by default and is silent while the tab is hidden or Chrome is in the background. However, it does not state whether the setting persists across tabs or sessions, whether toggling causes any side effects, or what happens to the overlay during screenshots or automation.

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

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

Two short sentences, front-loaded with the action and followed by the default behavior. There is 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?

For a simple two-boolean toggle with no output schema and no annotations, the description covers the basic purpose and defaults. It omits persistence, side effects, and when to use the tool versus leaving the overlay in its default state, leaving meaningful gaps for an agent deciding whether to invoke it.

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

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

Schema description coverage is 0%, so the description must compensate for both boolean parameters. It hints at defaults for "enabled" and "backgroundSilent" (silent while hidden/background), but never explicitly explains what passing false to either parameter does. An agent still has to infer the exact semantics of both booleans.

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: "Toggle the on-page cursor overlay." This clearly distinguishes it from sibling tools like browser_screenshot, browser_click, or browser_scroll. It stops short of naming alternatives or contrasting with related visual tools, so a 5 is not warranted.

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

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

The description explains defaults (enabled, silent in hidden/background tabs) but does not say when an agent should toggle the cursor versus leaving it alone. There is no guidance on when to disable it, when to enable background visibility, or how this interacts with sibling browser tools.

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

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

With no annotations, the description carries the full behavioral burden but discloses almost nothing: it doesn't say whether the call blocks, what it returns on success (element handle, boolean, nothing), or what happens when the timeout expires (error vs. false). 'Target tab' implies an implicit tab context that is never defined.

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

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

A single front-loaded sentence with zero filler, which is structurally sound. Its brevity borders on under-specification, but nothing is wasted or buried.

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

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

For a wait/polling tool with no annotations and no output schema, the description should at minimum cover return value, default timeout and failure mode. None of that is present, and the implicit tab targeting is undefined, so an agent cannot call this confidently in a multi-tab session.

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

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

Schema description coverage is 0%, so neither parameter is documented in the schema. The description clarifies 'selector' as a CSS selector, but 'timeoutMs' is never mentioned — no default, no units confirmation, no behavior on expiry — leaving a required-looking tuning parameter entirely unexplained.

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

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

The description states a specific verb ('Wait') and condition ('until a CSS selector exists'), which is unambiguous and clearly distinct from action siblings like browser_click or browser_type. It doesn't explicitly contrast with polling alternatives such as browser_snapshot or browser_status, but the wait semantics are self-evident.

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

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

There is no guidance on when to use this versus re-reading the page with browser_text/browser_snapshot, nor any prerequisite context about which tab is 'target' or how it is chosen. The agent is left to infer all usage conditions.

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