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 says the batch is 'rapid' but does not disclose execution order, failure semantics (does one failed action abort the rest?), atomicity, whether the batch is transactional, or how tab_index interacts with the actions. For a composite mutation-style tool this is a substantial gap.

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

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

A single front-loaded sentence with no filler, and the purpose plus its benefit are stated immediately. It is efficient, though it is arguably under-specified rather than optimally concise.

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

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

An output schema exists, so return-value explanation is not required. But the critical 'actions' payload format is undocumented in both schema and description, and with no annotations there is no fallback for safety or failure semantics. An agent cannot reliably construct a batch from this definition alone.

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

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

Schema description coverage is 0% and the 'actions' parameter is an untyped array of free-form objects (additionalProperties: true), so the schema explains nothing. The description only hints that the array holds 'browser actions' without identifying the allowed action types, their field shape, or what tab_index does. It adds marginal meaning over an empty schema.

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

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

States a clear verb+resource ('execute a sequence of browser actions') plus a distinguishing characteristic (single rapid batch). It implicitly separates itself from the single-action siblings like browser_click and browser_navigate, though it never names them explicitly.

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

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

The phrase 'to eliminate round-trip overhead' implies the usage context: batch multiple actions when you want fewer round trips. However, it gives no explicit when-to-use vs alternatives, no guidance on when a single call is preferable, and no stated prerequisites (e.g. an active tab/session).

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 behavioral burden, yet it says nothing about failure modes (element not found), whether clicking waits, or what wait_navigation/tab_index actually change. It only discloses accepted locator formats, which is a small fraction of the behavior an agent needs for a DOM-mutating 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 front-loaded sentence with zero padding; the locator list is arguably necessary content. It is efficient, though it trades away completeness 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?

An output schema exists so return values needn't be explained, but with no annotations, 0% schema coverage, and a behavior-affecting flag (wait_navigation) left undefined, the description is not sufficient for an agent to call this confidently.

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

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

Schema coverage is 0% and two of three parameters (tab_index, wait_navigation) are undocumented anywhere. The description does add real meaning for target by enumerating CSS selector, text, XPath, aria-label, title, and placeholder formats, which partially compensates, but the silence on the other two params leaves a clear gap.

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

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

States a specific verb (click) and resource (element) plus the accepted locator strategies, so the agent knows instantly what the tool does. It does not explicitly contrast itself with close siblings like browser_type or browser_focus, which keeps it just below a 5.

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

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

No when-to-use guidance, no prerequisites, and no alternatives named. The agent is left to infer that this is for clicking rather than typing, scrolling, or focusing, with no explicit routing to browser_type/browser_focus for those cases.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says 'close' but not whether closing the last tab ends the session, whether an invalid index errors or is ignored, whether closed tabs are recoverable, or whether unsaved state is lost. For a destructive operation with zero annotation coverage, this is a substantial gap.

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

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

A single efficient sentence that front-loads the action and covers both invocation modes without padding. Slightly terse given what is left unexplained, but nothing is wasted.

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

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

An output schema exists, so return values need not be described. However, for a destructive single-parameter tool with no annotations, the description omits the edge-case behavior (last tab, invalid index) an agent would need to invoke it safely.

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

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

Schema coverage is 0% and the single tab_index parameter has no description. The phrase 'or the current tab' does imply that omitting the parameter defaults to the active tab, which adds real meaning beyond the bare schema, but it never explains acceptable index values or their origin.

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 ('Close') and resource ('tab'), and distinguishes the two modes: a specific tab or the current tab. It is clearly separable from siblings like browser_new_tab and browser_switch_tab, though it doesn't name them explicitly.

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

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

No when-to-use guidance, no prerequisites, no mention of how tab_index is obtained (e.g., from browser_tabs) or what happens if it's omitted. The agent must infer that omitting tab_index targets the current tab.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that arbitrary JavaScript is evaluated, omitting side effects, mutation potential, security considerations, and whether the page context can be altered.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for the minimal amount of information it conveys.

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 powerful arbitrary code execution tool with no annotations, two parameters (one entirely undocumented), and ambiguous sibling overlap, the description is incomplete. The output schema exists, but it does not compensate for missing usage, security, or parameter 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 0%, so the description must compensate for both parameters. It implies the required 'expression' parameter but does not explain its format, and it says nothing about the optional 'tab_index' parameter.

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

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

The description states a specific verb ('Evaluate') and resource ('arbitrary JavaScript expression in the page context'), making the tool's basic purpose clear. However, it does not differentiate from sibling tools such as browser_run_code, which may also execute code in the browser.

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

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

There is no guidance on when to use this tool versus alternatives, no exclusions, and no mention of conditions or prerequisites. With siblings like browser_run_code and browser_batch, the agent is left to infer the appropriate context.

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

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

With no annotations, the description carries the full behavioral burden, yet it discloses nothing about what happens in headless mode, whether focusing fails or throws, whether it restores minimized windows, or any side effects. Only the bare intent is stated.

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

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

A single front-loaded sentence with no filler, which is efficient for a trivial action. It is arguably under-specified rather than verbose, but structurally it wastes nothing.

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

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

An output schema exists, so return values need not be described. However, for a tool with an undocumented parameter and no annotations, the description should still clarify the tab_index behavior and any failure mode; it leaves meaningful gaps.

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

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

Schema description coverage is 0% and there is 1 parameter (tab_index) that the description never mentions. The description neither explains what tab_index selects nor that it is optional/defaulted, leaving the parameter fully undocumented.

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

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

States a specific verb ('bring to the foreground') and resource (browser window), so an agent can identify the action. It is implicitly distinct from browser_switch_tab, but the description never names that sibling or clarifies the difference, so it falls short of full sibling differentiation.

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

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

There is no when-to-use guidance. The word 'Explicitly' faintly suggests the window may already be open but unfocused, but it never says when focus is necessary, when it's a no-op, or when to prefer browser_switch_tab or browser_launch instead.

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

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

No annotations are provided, so the description carries the full burden, yet it only lists output formats. It says nothing about how selector narrows extraction, how tab_index selects a tab, whether the call waits for load, or whether it fails if no page is open.

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 or repetition. It is efficient, though its brevity is partly due to under-specification rather than tight editing of a complete description.

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

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

An output schema exists, so return values need not be explained. However, for a 3-parameter tool with zero annotation coverage and 0% schema descriptions, the selector and tab_index semantics and any usage context are entirely missing, making the definition inadequate for reliable invocation.

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

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

Schema description coverage is 0%, and the description only adds meaning for 'format' by enumerating 'markdown', 'text', 'html'. The 'selector' and 'tab_index' parameters are undocumented in both the schema and the description, leaving most parameter semantics unexplained.

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

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

States a specific verb ('Extract') and resource ('page content') with the three supported output formats named. It implicitly distinguishes itself from siblings like browser_get_links, browser_screenshot, and browser_evaluate, though it never names an alternative explicitly.

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

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

There is no when-to-use guidance, no prerequisites (e.g., must a page be loaded first?), and no mention of alternatives such as browser_evaluate for scripted extraction. The agent must infer the context entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says 'all interactive hyperlinks' and 'current page' but omits whether the page must be loaded, whether it is read-only, whether hidden links are included, and whether hrefs/text are 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?

A single efficient sentence with the resource and scope front-loaded and zero 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?

An output schema exists, so return values need not be described. However, the unexplained tab_index parameter and absent usage guidance leave gaps for a browser automation tool with many siblings.

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 description never mentions tab_index. The phrase 'current page' weakly implies the active tab, but it doesn't explain what tab_index does or that it defaults to null, leaving the only parameter undocumented in both schema and description.

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

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

States a specific verb (extract) and resource (interactive hyperlinks) scoped to the current page. It is distinguishable from browser_get_content and browser_evaluate, though it doesn't explicitly say so.

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_get_content or browser_evaluate, both of which can also yield links. Usage is only implied by the purpose statement; no prerequisites or exclusions are given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the background/foreground distinction, but says nothing about whether the call is idempotent when Chrome is already running, what 'verify' actually does, permission requirements, or timeout/failure 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 the core action and then the one non-obvious parameter caveat. No filler or redundancy.

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

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

An output schema exists, so return values need not be explained, and the focus caveat is present. But with zero annotation coverage, no sibling differentiation, and two undocumented parameters, the description is only minimally sufficient for a lifecycle-launch 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 description coverage is 0% for three parameters. The description explains the focus flag well, but url and display are entirely undocumented in both the schema and the description, leaving two of three parameters opaque.

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 ('Launch or verify Chrome browser in the background'), which is clear enough to separate it from browser_navigate or browser_focus. However, 'launch or verify' is an odd dual purpose that isn't explained, and it doesn't explicitly distinguish itself from the other browser lifecycle siblings like browser_status.

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

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

The focus sentence gives one conditional ('only if you explicitly want to bring it to the foreground'), which is useful usage guidance for one parameter. But there is no guidance on when to call this versus browser_status, browser_focus, or browser_navigate, and no prerequisites or state assumptions are stated.

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

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

With no annotations, the description carries the full behavioral burden and does not disclose whether navigation waits for page load, what happens to existing tab content/history, or how failures are surfaced. 'Navigate a tab' implies a browser session exists but says nothing about required session state or auth.

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

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

A single front-loaded sentence with no filler; the action and target come first. It is efficiently sized, though the brevity reflects under-specification rather than true economy.

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

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

An output schema exists, so return values need not be explained, but for an action tool with zero annotations and zero parameter documentation the definition leaves too much unspecified: session preconditions, tab_index behavior, and load semantics are all missing.

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

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

Schema description coverage is 0%, so the description must compensate. It only implicitly covers the required url parameter and says nothing about tab_index — an agent cannot tell whether tab_index selects an existing tab, defaults to the active tab, or what null means.

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 (Navigate) and resource target (a tab, to a URL), so the agent knows this is a navigation action rather than a click/type/scroll. It does not distinguish itself from siblings like browser_new_tab or browser_launch, which could both plausibly involve a URL.

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

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

There is no when-to-use guidance, no prerequisites (e.g., that a browser session must already be launched), and no mention of alternatives such as browser_new_tab for opening a fresh tab. The agent must infer all selection criteria.

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

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

No annotations are provided, so the description carries the full behavioral burden. It doesn't say whether the new tab receives focus, how an existing active tab is treated, or whether a supplied URL is loaded immediately. For a state-changing tab operation with zero annotation coverage, this is a real gap.

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

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

A single front-loaded sentence with no wasted words. The purpose is stated before any detail, which is exactly right for a simple one-parameter tool.

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

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

The output schema covers return values, so the description needn't explain them. Still, with no annotations and a 0%-covered parameter, the definition is thin on focus behavior and the new-tab-versus-navigate decision.

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

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

Schema description coverage is 0%, and the description only restates that 'url' is optional and a URL, adding nothing about accepted formats or behavior when it is omitted. With one undocumented parameter, the description does not compensate for the coverage gap.

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

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

States a specific verb and resource ('Open a new browser tab'), which clearly identifies the action. However, it offers no differentiation from close siblings like browser_launch, browser_navigate, or browser_tabs, so the agent must infer the distinction.

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

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

No guidance on when to open a new tab versus navigating in an existing one (browser_navigate) or switching tabs (browser_switch_tab). The only hint is the word 'new', leaving the choice between siblings to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it is silent on where the key is delivered (focused element vs. active tab), whether focus is required first, whether modifiers/shortcut combinations are supported, or whether the action can trigger page navigation. The key examples are the only real information offered.

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

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

A single tight sentence with no filler and the core action front-loaded. It is efficient, though arguably undersized given the complete absence of schema documentation.

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

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

An output schema exists so return values need no explanation, but the tool has two undocumented parameters, no annotations, and no usage context. For an input tool with 0% schema coverage, the description does not provide enough for an agent to call it confidently.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. The key-name examples ('Enter', 'Escape', 'ArrowDown') do clarify the expected key format, which is genuinely useful, but 'tab_index' is left entirely unexplained in both the schema and the description.

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

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

States a specific verb and resource ('Press a keyboard key') with concrete examples of valid key names. It is clear enough to distinguish from browser_type and browser_click, though it never explicitly contrasts itself with 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 description gives no guidance on when to use this tool versus browser_type, browser_click, or browser_focus, and no prerequisites (e.g. an element must be focused first). Usage is only implied by the tool name.

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

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

No annotations are supplied, so the description carries the full burden. It implies persistence ('resident browser daemon') but says nothing about whether the code runs sandboxed, what page/DOM access it has, mutation risk, timeouts, or error behavior for arbitrary Python — significant gaps for a code-execution tool.

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

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

A single front-loaded sentence with no filler, which is structurally clean. It is arguably terse to the point of under-specification for a high-risk execution tool, but there is no wasted text.

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

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

An output schema exists so return values need not be explained, but for a tool that executes arbitrary Python in a live browser with zero annotations and zero parameter documentation, the description omits what an agent must know to call it safely and correctly.

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

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

Schema description coverage is 0% with two parameters. The phrase 'Python automation code' incidentally conveys the language for 'code', but nothing is said about available APIs, globals, or context. 'tab_index' is completely undocumented in both schema and description, including whether it defaults to the active tab.

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 (Execute) and resource (Python automation code in the resident browser daemon), which is clearer than a generic 'run code'. It does not, however, distinguish itself from close siblings like browser_evaluate or browser_batch, so an agent cannot tell from the text alone which execution surface to pick.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. With siblings such as browser_evaluate, browser_batch, and browser_get_content present, the description leaves the routing decision entirely to inference.

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

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

With no annotations, the description carries the full behavioral burden, yet it only states that a PNG is saved. It does not disclose side effects such as where the file is written by default, whether an existing file is overwritten, whether the operation requires an active tab, or whether it is safe/read-only. The output format disclosure is the only behavioral detail present.

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

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

The description is a single, front-loaded sentence with no filler. However, given the tool has three undocumented parameters and no annotations, the terseness leaves important context unaddressed, making it slightly under-specified for the complexity involved.

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

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

An output schema exists, so return values need not be explained, but the description still fails to cover the three input parameters, usage context, or behavioral side effects. For a tool with 0% schema description coverage and no annotations, this is insufficient to call it correctly in all cases.

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 three parameters (full_page, tab_index, output_path), and the description mentions none of them. It says 'active page,' which actually conflicts with the tab_index parameter that allows targeting a different tab, and it does not explain full_page or output_path at all. The description adds no meaning beyond the bare parameter names.

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

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

The description states a specific verb ('Capture') and resource ('screenshot of the active page') plus the output format ('PNG'), so the core action is clear. It does not explicitly differentiate from siblings like browser_get_content or browser_evaluate, but the tool's purpose is distinctive enough that an agent can identify it without opening the schema.

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

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

There is no guidance on when to use this tool versus alternatives such as browser_get_content for text or browser_evaluate for data extraction. It also omits prerequisites like whether a browser must already be launched or a page navigated to. The agent receives no 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 behavioral burden, yet it only enumerates scroll modes. It says nothing about whether scrolling is synchronous, whether it triggers lazy-loading, whether it needs a focused/active tab, or what side effects occur. The listing of modes is the only behavioral signal.

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

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

A single short sentence that front-loads the verb and enumerates modes efficiently. It is appropriately sized, with the only wasted value being the unsupported pixel-amount claim.

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 modifies page viewport state and has two completely undocumented parameters, a mismatch between the described pixel-scroll capability and the schema, and no prerequisites stated. An output schema exists so return values need not be described, but the input-side gaps are substantial.

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 direction values (up/down/top/bottom) but never explains tab_index, and it advertises scrolling 'by specific pixel amount' even though the schema exposes no pixel parameter and no enum, making that claim unsupported by the actual inputs.

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

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

The description gives a specific verb (scroll) and resource (page) plus the supported modes (up, down, top, bottom, pixel amount), which is far more than a tautology. It is unambiguous against the sibling list since no other tool deals with scrolling, though it does not explicitly name a sibling it differs from.

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

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

There is no when-to-use or when-not-to-use guidance, no mention that a browser/tab must already be launched, and no indication of how this relates to browser_wait or browser_get_content when content must be loaded. The agent must infer all context.

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

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

No annotations are provided, so the description carries the full burden. 'Check' implies a read-only, non-mutating probe and it enumerates the observed state (status, tabs, CDP connection), but it never states whether it errors when no browser is launched, whether it is safe to call repeatedly, or whether it can block.

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

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

A single front-loaded sentence with no filler; every word contributes. It is arguably terse for a tool with no annotations, but there is no wasted structure.

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

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

An output schema exists, so return values need not be described, and with zero parameters there is nothing to document on the input side. The only shortfall is the missing note on the precondition that a browser session must exist.

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

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

The tool takes zero parameters, so the baseline is 4. The description correctly adds nothing about inputs because there are none, and the empty schema leaves no ambiguity to resolve.

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

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

The description gives a specific verb ('Check') and names three concrete resources: browser status, active tabs, and CDP connection state. It is clear what the tool reports, but it does not differentiate itself from the overlapping sibling browser_tabs, which also concerns tabs.

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

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

There is no statement of when to call this versus alternatives such as browser_tabs or browser_launch, nor any prerequisite (e.g., whether a browser must already be running). Usage is only tautologically implied by the word 'Check'.

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

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

With no annotations, the description carries full behavioral burden. 'Gracefully' is a genuine trait beyond the empty schema, but it says nothing about the fate of open tabs, in-flight operations, or session/auth state on shutdown.

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

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

A single front-loaded sentence with no filler. Every word earns its place for a zero-argument 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?

The output schema exists so return values need no explanation, and the tool is trivial to invoke. However, for a process-terminating action with no annotations, the definition is thin on effects and prerequisites.

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 there is nothing for the description to disambiguate. The baseline for a parameterless tool applies.

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

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

States a specific verb ('stop') and resource ('the background browser process'), and 'Gracefully' narrows the semantics versus a hard kill. It implicitly separates this from tab-level siblings like browser_close_tab, but never names a sibling to confirm 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?

No guidance on when to prefer this over browser_close_tab or browser_tabs, nor any prerequisite such as having launched the browser first. The agent must infer that this tears down the whole process rather than a tab.

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

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

With no annotations provided, the description carries the full behavioral burden, yet it omits the single most important detail: whether tab_index is 0-based or 1-based, and what happens when the index is out of range or the tab is closed. It also doesn't state that this mutates the browser's active-tab state (a side effect an agent should know about).

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

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

A single front-loaded sentence with no filler; the verb and target are immediately clear. It is efficient, though its brevity borders on under-specification for a state-mutating tool.

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

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

An output schema exists so return values need not be explained, and there are no nested objects. But for a 1-required-parameter mutation tool with zero annotation coverage, the description should cover index base, invalid-index behavior, and the browser_tabs/browser_focus relationship — none of which appear.

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 one required parameter, so the description must compensate — but 'tab index' merely restates the parameter name. It adds no indexing base, no valid range, and no hint about how indices are obtained (e.g., from browser_tabs).

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 plus resource ('Switch active focus to a specific tab index'), which is clearer than a bare 'switch tab' and partially distinguishes it from the similarly named sibling browser_focus by scoping it to tabs. However, it never clarifies how it differs from browser_focus or browser_new_tab, leaving an agent to guess which of the two focus-related tools applies.

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

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

There is no when-to-use guidance at all — nothing about needing a tab to already exist, about calling browser_tabs first to enumerate indices, or about how this relates to browser_focus. The agent is left to infer the invocation context entirely.

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

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

With no annotations provided, the description carries the full behavioral burden and discloses almost nothing beyond the action itself. It does not state that the operation is read-only and side-effect free, nor whether a browser must be launched first or what happens if no session exists.

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, appropriately sized for a zero-parameter read tool. Nothing is redundant or buried.

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

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

The tool is simple, takes no arguments, and has an output schema that documents the return shape, so the description need not explain return values. The remaining gap is the absence of any session/prerequisite context, which is minor for a listing 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?

The tool takes zero parameters, so there is nothing for the description to compensate for; baseline 4 applies. The empty schema is consistent with the no-argument description.

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

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

The description gives a specific verb and resource ('List' + 'tabs'), so the agent immediately knows what the tool returns. It does not, however, distinguish itself from the closely related tab siblings (browser_switch_tab, browser_close_tab, browser_new_tab), which all operate on the same resource.

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

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

There is no statement of when to use this tool versus alternatives, no prerequisites (e.g. an active/launched browser session), and no exclusions. The agent must infer usage purely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about whether the element is focused first, whether it waits for the element, or how clear_first/press_enter alter behavior. For a state-mutating browser action this is a significant gap.

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

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

A single, front-loaded sentence with no filler. Efficient, though the brevity is partly under-specification rather than disciplined conciseness.

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

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

An output schema exists so return values need not be described, but with no annotations, 0% param coverage, and a mutating browser action, the description leaves too much unspecified for an agent to call it reliably.

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

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

Schema description coverage is 0%, so the description must compensate, but it only loosely relates to 'target' via the element-type list. The clear_first, press_enter, and tab_index parameters are left completely unexplained in both the schema and the description.

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

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

The description gives a specific verb ('type or fill') and resource, and even narrows it to input, textarea, or contenteditable elements, which is more informative than a bare name restatement. It does not explicitly distinguish itself from siblings like browser_click or browser_press_key, but the element-type scope makes the action recognizable.

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

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

There is no guidance on when to use this tool versus alternatives such as browser_press_key or browser_click, nor on prerequisites like focusing or waiting for the element. Usage must be inferred entirely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the two waiting mechanisms and a concrete seconds format, but is silent on the most important behavioral trait for a wait tool: what happens on timeout (error, silent return, or hang) and whether the call blocks.

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 an inline example; every clause carries information and nothing is padded.

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

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

An output schema exists, so return values need not be explained, and the two wait modes are covered. However, for a tool whose correctness hinges on timeout/error behavior and on which tab is targeted, both omissions leave real gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the dual semantics of target_or_seconds with an example ('2.5'), which the schema alone does not, but it says nothing about tab_index, leaving one of two parameters entirely undocumented.

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

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

States a specific verb (wait) and two concrete resources/conditions (a duration in seconds, or a CSS/text selector appearing), which is far more specific than the bare tool name. It does not, however, differentiate itself from siblings such as browser_get_content or browser_evaluate that an agent might reach for when waiting for content.

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 dual-mode description ('wait for seconds ... or wait for a CSS/text selector to appear') implicitly tells the agent this is the tool for synchronization before reading or clicking. There is no explicit when-not, no timeout guidance, and no named alternative (e.g. browser_evaluate) for more complex waits.

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