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

Annotations already mark the tool as read-only, idempotent, and non-destructive, lowering the description's burden. The description adds value by spelling out exactly which state facts are reported, including the no-tab_id default and cross-run tab counts. There is no contradiction with the annotations.

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

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

A single front-loaded sentence states the verb and resource first, then lists the key outputs. Every phrase contributes a distinct piece of information with 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?

For a zero-parameter status tool, the description plus annotations cover the essentials: the agent knows it is safe, idempotent, and what categories of state it will receive. The explicit itemized report list mitigates the lack of an output schema. Exact return formatting is unspecified, but that is not critical for correct invocation.

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

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

With zero parameters, the schema fully covers the input surface and there are no parameter semantics to clarify. The baseline of 4 applies because the description does not need to compensate for any schema gaps.

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

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

The description uses a specific verb ('Report') and names a precise resource ('Arc state'), then itemizes four concrete data points. This distinguishes it from sibling tab and space tools that perform actions or list individual resources. The only minor ambiguity is the phrase 'previous run of this label,' but the overall purpose is unmistakable.

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

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

The description clearly conveys that this is a status/diagnostic call rather than a tab manipulation operation. The enumerated items imply the triggering situations: checking ownership, default tab resolution, and leftover counts. It does not explicitly name alternatives or exclusions, so it stops short of a 5.

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

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

Beyond the annotations, the description discloses important runtime behavior: execution stops at first failure unless continue_on_error is set, and results are capped at 60000 characters, causing early stopping and truncation reporting. This adds real operational context beyond readOnlyHint, idempotentHint, and destructiveHint. It does not contradict the annotations.

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

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

The description is three dense sentences with no filler. It front-loads the core purpose, then covers failure handling, use case, and a concrete limit. Every sentence earns its place.

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

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

The description covers ordering, tab propagation, error behavior, truncation limits, and practical usage. Because there is no output schema, the description could have said a bit more about the exact result shape, but it does state that results exist and can be truncated. This is nearly complete for a tool of this complexity.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds useful context by explaining 'passing the same tab through' and by mentioning max_chars for reading steps, but it does not substantially deepen per-parameter semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Run several tools in order in one call, passing the same tab through.' This clearly defines batch orchestration and distinguishes it from the individual browser-action sibling tools. The example 'fill, fill, click, wait' reinforces the intended function.

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 explicitly recommends the tool for cutting round trips and gives a concrete sequence. It also implies when to avoid a single batch by warning that read-heavy sequences should be split or constrained with max_chars. It does not name an alternative tool, but the guidance is clear enough for an agent to decide.

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 say readOnlyHint=false, openWorldHint=true, and destructiveHint=false. The description adds meaningful context beyond that: it dispatches a real pointer sequence so framework handlers fire, scrolls the element into view, and warns that urlBefore may be captured before navigation settles, recommending wait_for_load. This is rich behavioral disclosure that complements the annotations without contradicting them.

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?

Every sentence carries essential information: selector formats, real pointer behavior, matching semantics, matches count guidance, and the urlBefore caveat. It is dense but not bloated, and the essential 'Click an element' is front-loaded, so an agent gets the core purpose immediately.

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

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

For a tool with five parameters, matching subtleties, and navigation implications, the description covers everything an agent needs to call it correctly: return fields (matches, urlBefore), how to use the returned data, and when to wait for load. The lack of an output schema is compensated by the explicit mention of return values, making it fully self-contained.

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%, but the description goes further by explaining the interaction between parameters: how 'text=' matching ranks exact over substring, how nth order follows that ranking, and how the matches count guides the use of exact. This decision-rule level of explanation is exactly the added value expected beyond raw schema types.

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 starts with 'Click an element' — a specific verb and resource — and immediately clarifies the two accepted selector formats. It differentiates the tool from siblings like fill and press_key by focusing on the click action and its pointer-sequence behavior, leaving no ambiguity about what it does.

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

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

It gives concrete when-to-use guidance: check the returned 'matches' count, set exact when matches exceed 1, and follow with wait_for_load after navigation. It also explains the matching ranking and scrolling, implicitly telling the agent when to rely on this tool versus a simple query or input tool. The explicit follow-up instruction is a strong usage guideline.

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

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

Annotations already mark this destructive, and the description adds significant scoping context: user tabs are untouched, stale tabs from dead sessions are excluded by default, and live agent tabs are never affected. This clearly defines the boundaries of the destructive action and prevents accidental data loss beyond the agent's own tabs.

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

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

Two sentences with no filler. The main behavior is front-loaded, and the stale-tab exception is placed immediately after. Every sentence earns its place and directly informs invocation.

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-optional-parameter cleanup tool, the description covers the action, the ownership boundary, the stale-tab behavior, and points to arc_status for relevant status. No output schema exists, but nothing needed to call the tool correctly is missing.

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

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

The schema already describes include_stale fully, including its default value and effect. The description mentions include_stale only in passing, matching the schema without adding new meaning. With 100% schema coverage, the baseline 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Close every tab this agent opened.' It precisely scopes the tool to tabs owned by this agent and distinguishes it from close_tab and user-tab operations. The mention of 'leaving the user's tabs alone' removes ambiguity about which tabs are affected.

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 makes the intended cleanup use clear: close all agent-opened tabs, not user tabs. It also gives explicit guidance for include_stale, noting stale tabs are left alone unless the flag is set. It does not explicitly mention sibling alternatives like close_tab, so it stops short of full alternative routing.

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

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

Destructive behavior is clearly disclosed: 'Closing cannot be undone and tab ids are not reused.' It also explains the fallback resolution behavior for omitted tab_id, adding value beyond the destructiveHint annotation and making side effects explicit.

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?

Four sentences deliver the action, fallback behavior, safety warning, and alternative tool guidance with no filler. The most important information is front-loaded and every sentence earns its place.

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

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

For a single-parameter destructive tool with full schema coverage and relevant annotations, the description covers everything needed to invoke it correctly: what it acts on, what happens without an argument, the irreversible consequence, and when to use the sibling tool instead.

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

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

The schema already fully documents tab_id at 100% coverage, including the omit behavior. The description reinforces this but does not add substantially new parameter-level information beyond the 'unless you are certain' caution. A baseline of 3 is appropriate given the complete schema coverage.

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

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

'Close one tab' is a specific verb and resource, and the description distinguishes this from sibling close_own_tabs by pointing to the cleanup use case. It clearly identifies what the tool does and how it differs from alternatives.

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

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

The description explicitly tells when to pass tab_id ('unless you are certain') and when to prefer close_own_tabs ('To clean up after yourself'). It also explains what happens when tab_id is omitted, covering the main usage decision points.

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

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

Annotations already flag destructiveHint=true, openWorldHint=true, and readOnlyHint=false, so the description is not the sole safety signal. It adds value by explaining that results are returned and that both expressions and return-based statements work, but it does not elaborate on side-effect risks of arbitrary JavaScript.

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

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

Three short, front-loaded sentences with no filler. The first sentence states the core behavior; the second and third add return semantics and helper availability. Minor redundancy with the schema's code description keeps it from a 5.

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

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

The description plus schema covers how to provide code, how to choose a tab, and helper availability, which is enough to invoke the tool. No output schema exists, but the return mechanics are described. It does not address error/async behavior or the scope of side effects, though annotations carry part of that burden.

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% for both code and tab_id, so the baseline is already strong. The description goes beyond the schema by naming the available helper library A and its methods (A.all, A.one, A.click, etc.), which materially helps an agent construct valid code.

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 opening sentence names a specific action and resource: 'Run JavaScript in a tab and return the result.' This clearly distinguishes it from sibling tools such as get_page_content and query_elements, and the following sentences clarify evaluation semantics.

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

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

The description gives no explicit guidance about when to choose execute_javascript over sibling tools, no exclusions, and no prerequisites. The helper-library note and return behaviors are operational details, not selection guidance.

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

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

The description discloses that it uses the native setter, fires input/change events so React registers the change, and fails with an error naming the tag. These behavioral details go well beyond the readOnlyHint/destructiveHint annotations and help the agent predict 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?

Every sentence carries operational weight: the action, the framework-compatibility mechanism, the failure modes, and the selector-matching rule. It is front-loaded with the primary purpose and contains 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 7-parameter mutation tool with no output schema, the description covers the main edge cases, selector ambiguity, and failure behavior, while the schema covers parameter defaults. Nothing needed for correct invocation is missing.

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

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

The schema already documents all 7 parameters at 100% coverage, so the baseline is 3. The description adds practical matching semantics (substring matching with exact matches ranked first) and a concrete ambiguity-resolution instruction that goes beyond the schema's field descriptions.

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

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

The description opens with a specific verb and resource ('Set the value of an input, textarea or contenteditable') and immediately distinguishes the tool from siblings by listing what it cannot fill, e.g. '<select> (use select_option for those)'.

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

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

It explicitly names the alternative for selects, warns when filling will fail (non-inputs, disabled/readonly fields), and provides a decision rule for ambiguous label matches: check the returned 'matches' count and pass exact when above 1.

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

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

Beyond the annotations, the description discloses a key behavioral trait: switching a space changes what the user sees, and unfocused-space tabs remain fully accessible. This adds meaningful context that the annotations do not capture. No contradiction with annotations found.

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 compact sentences with no filler. The core action comes first, and the important behavioral caveat follows without unnecessary detail.

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

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

For a low-complexity, single-parameter action, the description plus schema covers the target, the source of valid identifiers, and a critical side-effect warning. The lack of output schema is not a material gap for a focus operation.

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

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

The schema already fully documents the only parameter ('Space id or title from list_spaces'), so the description adds no new parameter information. Baseline 3 is appropriate given 100% schema description coverage.

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

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

The description states a specific verb and resource: 'Switch the front Arc window to a space.' This clearly differentiates focusing a space from tab-level operations like switch_to_tab or listing operations like list_spaces.

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

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

It explicitly frames when the tool is appropriate ('rarely needed') and gives the underlying reason (tabs in unfocused spaces are still readable and scriptable). It does not name explicit alternatives or a hard when-not-to-use condition, but the guidance is clear and actionable.

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

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

Annotations already establish that the tool is read-only, idempotent, and non-destructive, so the bar for extra behavioral disclosure is lower. The description adds the fallback resolution behavior: the agent's current tab, or the active tab if the agent has none. This is useful context beyond the annotations.

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

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

The description is a single, front-loaded sentence with a colon separating the core action from the fallback explanation. Every word earns its place, and there is no filler or repetition beyond what the schema already 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 one-parameter, read-only, idempotent tool, the description plus annotations cover safety profile, default behavior, and parameter handling. The main unstated detail is the exact shape of the returned tab object, but that is minor given the simple purpose.

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

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

The input schema already covers the single parameter tab_id fully, including the omit behavior. The description essentially restates the schema's meaning ('a call with no tab_id') rather than adding new parameter-level detail, so it meets the baseline but does not exceed it.

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

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

The description uses a specific verb and resource: 'Get the tab a call with no tab_id would act on.' It clearly identifies the tool's unique role as resolving the default tab target, distinguishing it from siblings like list_tabs and get_page_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 description gives clear context for when to use the tool: to determine which tab an action would affect when no tab_id is provided. It does not explicitly name alternatives or state when not to use it, but the default-target framing is enough to guide an agent.

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

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

Annotations already establish readOnly, idempotent, and non-destructive behavior. The description adds useful behavioral detail: it returns one element only, reports how many matched, and uses the nth parameter to select a different match. This goes beyond the annotations, though it does not mention truncation behavior covered by max_chars.

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

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

Two sentences with no filler. The core purpose is front-loaded, and the important selection behavior is stated compactly without 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?

Together with the fully documented schema, the description covers the key selection semantics and parameter usage. The absence of an output schema is mitigated by the description's mention of matched-count reporting and nth selection, though explicit return-shape details are not provided.

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

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

The schema has 100% parameter coverage, so the baseline is 3. The description adds value by clarifying the nth parameter's purpose ('pick a different one') and the one-element-return behavior, which supplements the schema's more formal definitions.

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

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

The description uses a specific verb ('get') and identifies the resource ('HTML of a page or element'), and it distinguishes itself from text-oriented retrieval by saying 'rather than text.' However, it does not explicitly name sibling tools such as get_page_content or query_elements, so differentiation is clear but not exhaustive.

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 explicit guidance on when to use it: when markup, attributes, or structure are needed rather than text. It does not mention exclusions or alternative tool names, but the stated context is enough for an agent to route correctly.

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

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

The annotations already cover read-only, idempotent, and non-destructive behavior. The description adds meaningful context beyond that: it clarifies that hrefs are 'resolved' and explains why duplicates occur ('navigation and footers produce in bulk'), helping the agent understand output characteristics.

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 concise sentences, with the core action front-loaded and the optional deduplication behavior explained immediately after. Every sentence earns its place and no wording 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?

The description, combined with a fully documented schema and safety annotations, covers the essential behavior: what is listed, what link fields are returned, and how deduplication works. It could be slightly stronger by naming sibling tools like query_elements as alternatives, but no critical information is missing.

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

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

Schema description coverage is 100%, so the schema fully documents limit, query, tab_id, and unique. The description repeats the unique parameter's purpose with extra context about duplicate sources, but does not add substantial semantic value 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: 'List links on the page with their text and resolved href.' This clearly distinguishes the tool from siblings like get_page_content or query_elements, which extract general content or elements rather than link-specific data.

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

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

The description gives clear context that this tool is for extracting links with text and href values, and adds conditional guidance for the unique flag. It does not explicitly name alternatives or state when not to use it, but the specialized purpose makes intended usage apparent.

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

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

Annotations already cover read-only, idempotent, open-world, and non-destructive behavior. The description adds meaningful behavioral context: the joined-with-blank-lines format, the always-reports-'matched' guarantee, and the nested-match duplication quirk, all beyond what annotations provide.

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

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

Three tight sentences with no filler. The first sentence delivers the core capability, and each following sentence adds distinct, useful behavioral or selection guidance.

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

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

For a read-only, idempotent tool with 100% parameter documentation and safety annotations, the description covers output format, truncation indirectly, sibling-relevant selector behavior, and the partial-result guarantee. A brief note on when to prefer a sibling tool would make it fully complete.

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

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

Schema description coverage is 100%, so the input schema fully documents tab_id, selector, max_chars, and first_only. The description reinforces selector semantics but does not meaningfully add beyond the schema, so the baseline of 3 is appropriate.

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

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

States a specific verb and resource: 'Get the visible text of a page, or of every element matching a selector joined with blank lines.' This clearly conveys what the tool returns, though it does not explicitly differentiate from siblings like get_html or query_elements.

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?

Offers operational guidance such as preferring a leaf-ish selector to avoid nested repetition and noting that a partial answer is never silent. However, it never says when to choose this tool over alternatives like get_html, get_links, or query_elements, leaving routing 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?

Annotations already declare readOnly, openWorld, idempotent, and non-destructive behavior. The description adds the useful 'cheap' performance characteristic and clarifies that it returns counts and metadata rather than full content. It does not contradict the annotations, but also adds limited behavioral context beyond them.

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. The output fields are listed compactly and the usage intent is front-loaded with 'Page overview' and reinforced by 'Cheap orientation before deciding what to do.'

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

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

The description lists the main returned fields and gives a clear use case, and the schema covers the only parameter and its fallback behavior. With no output schema, listing fields is helpful, though the exact shape of the response is not specified; overall adequate for a low-complexity 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 100%, with tab_id fully documented including fallback behavior when omitted. The tool description adds no parameter-specific information because the schema already carries that burden; baseline 3 is appropriate.

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

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

The description clearly identifies the tool as a page overview that returns orientation data: title, URL, ready state, meta description, headings, and form/frame counts. It distinguishes itself from heavier siblings like get_page_content and get_html by emphasizing 'overview' and 'cheap orientation,' though it lacks a direct verb like 'gets'.

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?

'Cheap orientation before deciding what to do' explicitly frames when to use it: as a lightweight first step before deeper actions. It does not name alternative tools or state when not to use it, but the orientation context is clear and actionable.

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

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

Beyond the annotations, the description reveals important behavioral nuance: it 'goes through the page' rather than issuing a browser-level command, and it verifies the result against the tab URL instead of assuming success. This adds meaningful context that annotations alone do not provide. No contradiction with readOnlyHint=false or destructiveHint=false.

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, no filler, with the core action front-loaded and the second sentence dedicated to a high-value differentiator. Every phrase contributes to correct invocation or selection.

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 optional-parameter navigation tool, the description plus schema and annotations cover the main operational requirements well. The main gap is the absence of any explicit statement about return value or output shape, but this is a minor omission given the simplicity of the operation and the absence of an output schema.

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

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

Schema description coverage is 100%, and the input schema already documents tab_id, timeout_ms, and wait_until_loaded in detail. The tool description itself adds no parameter-level meaning, so the baseline of 3 applies.

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

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

The description opens with a specific verb and resource: 'Navigate a tab back in history.' It immediately distinguishes the tool from forward navigation and from Arc's native command by noting it works on background tabs. An agent can understand exactly what this tool does 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?

The description gives a clear use case: navigating a background tab back, which it explicitly contrasts with 'Arc's own back command.' It does not explicitly enumerate when not to use this tool or compare it to sibling tools like go_forward, so it stops short of full when/when-not guidance.

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

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

The description adds a meaningful behavior beyond annotations: 'confirms the tab really moved before reporting success.' This tells the agent the tool verifies navigation rather than blindly returning, which is useful and not redundant with readOnlyHint=false or destructiveHint=false.

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, both earning their place: the first states the primary action and the second adds the verification behavior. No filler or redundant restatement of the tool name.

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 navigation operation, the description is sufficient: it identifies the action, confirms a verification step, and openWorldHint and destructiveHint=false provide safety context. With no output schema, it would have been stronger to mention the return value, but the success-reporting hint partially covers this.

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 every parameter's meaning is already documented in the schema. The description does not add parameter-level detail beyond the schema, which makes the baseline 3 appropriate.

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

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

The description states a specific verb and resource: 'Navigate a tab forward in history.' The word 'forward' clearly separates this tool from the sibling go_back, and the confirmation behavior further clarifies its identity. An agent can distinguish this tool 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?

The description makes the intended use clear by saying 'forward in history,' but it does not explicitly mention go_back or state when this tool should be preferred over alternatives. Usage is implied rather than directly guided.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, covering the safety profile. The description adds front-window scoping, the fact that pinned tabs are excluded from space counts, and the reconciliation formula (tabsInSpaces + topAppCount = totalTabs). This goes beyond annotation coverage, providing useful behavioral context, though it doesn't describe the exact return structure.

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 three sentences, front-loaded with the core purpose, followed by two concise clarifying details. No redundant or vague phrasing.

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

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

Given zero parameters and no output schema, the description provides sufficient context: what it returns (tab counts, active indicator), the window scope, reconciliation with pinned tabs, and the relationship to list_tabs. An agent can call it correctly and interpret results without additional information.

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

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

The tool takes no parameters (input schema is empty), so there is nothing for the description to add. Baseline of 4 for zero-parameter tools is appropriate.

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

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

The description states a specific verb (list), resource (Arc spaces), and scope (front window), and adds tab counts and which space is active. It explicitly differentiates from list_tabs by noting the window coverage ('Counts cover the front window only, while list_tabs covers every window'), making the purpose unambiguous.

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

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

It explicitly contrasts with list_tabs ('Counts cover the front window only, while list_tabs covers every window'), giving a clear selection rule. It also explains the reconciliation logic for pinned tabs (topApp), helping the agent decide when this tool's output is appropriate.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior, lowering the burden on the description. The description adds useful behavioral context by explaining row flags and the default scope, which is valuable beyond what annotations provide.

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

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

The description is two sentences with no filler, front-loading the core purpose before the behavioral details. Every clause earns its place and contributes to correct tool invocation.

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

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

For a read-only listing tool with four optional parameters, the description covers the essential behaviors: default scope, row flags, and narrowing via scope. Minor details like ordering or result limits are not specified, but they are not critical for an agent to call this tool correctly.

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

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

The input schema is fully documented at 100% coverage, so the schema already carries the parameter meaning. The description adds only a minor clarification about the scope parameter's default and effect, which is otherwise already present in the schema.

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

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

The description uses a specific verb and resource ('List Arc tabs') and immediately clarifies the key row semantics ('mine' and 'isActive'), making the tool's purpose unambiguous. This is enough to distinguish it from siblings like get_current_tab or close_tab even without naming them.

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 clearly states the default behavior ('Defaults to every tab') and the way to narrow it ('pass scope 'own' to narrow'), giving agents concrete context for invocation. It does not explicitly discuss when to prefer this tool over alternatives, so it stops short of a 5.

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

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

The annotations only say the tool is not read-only and touches the outside world. The description adds meaningful behavioral details: Arc is launched if needed, new tabs target the agent space or main window, and Arc auto-selects new tabs, restoring the previous selection unless activate is passed. These non-obvious behaviors go well beyond the structured annotations.

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

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

The description is compact, front-loaded with the core action, and every sentence adds useful behavioral context. There is no redundancy or filler, making it easy for an agent to parse quickly.

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

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

Given 8 parameters, 100% schema documentation, and no output schema, the description covers the main non-obvious runtime behaviors: launching Arc, space routing, and tab selection. Combined with the richly documented input schema, an agent has enough context to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra semantic value by explaining the default space behavior and by clarifying why the activate parameter exists: the prior tab selection is restored unless activate is passed. This is more than the schema alone provides.

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

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

The description states a specific verb and resource: 'Open a URL in Arc.' It also adds important scope details such as launching Arc if needed, so an agent can distinguish this from tab-management and navigation siblings like reload_tab or switch_to_tab.

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

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

The description makes the core use case clear and gives context about where new tabs land, but it does not explicitly state when to prefer this tool over alternatives like reload_tab or wait_for_load. No when-not conditions or alternative names are given, so guidance is mostly implied.

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

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

Beyond the annotations, the description discloses supported key categories, the no-selector fallback, and the exact minimal return shape (tag plus id/name/type/aria-label). The return caveat is valuable because no output schema exists, and it does not contradict the annotations.

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

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

Three sentences, front-loaded with the primary action, then capabilities, then the return limitation and alternative. Every sentence earns its place, and there is no filler or redundancy with the schema.

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

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

With no output schema, the description adequately explains what the tool returns and directs the agent to query_elements for richer data. All four parameters are fully documented in the schema, and the key decision (selector vs focused element) is called out, so the agent can invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning for selector behavior ('focused element when no selector is given') and reinforces valid key values, which goes slightly beyond what the schema alone states. It does not add detail for exact or tab_id, but the schema already covers those.

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

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

The description opens with a specific verb and resource ('Dispatch a key press to an element'), then clarifies the fallback target ('focused element') and supported key forms ('named keys ... and single printable characters'). This clearly separates it from mouse-interaction siblings like click and fill.

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

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

It explicitly states when the focused element is used ('when no selector is given') and points to query_elements as the alternative when a full element picture is needed. It does not enumerate exclusions relative to click/fill/select_option, but the guidance is clear enough for correct invocation.

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

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

Annotations already establish readOnlyHint, idempotentHint, and non-destructive behavior, so the description correctly focuses on semantics beyond safety: text matching is substring, exact matches are ranked first, and passing exact requires a full match. This is valuable behavioral information that prevents incorrect assumptions about selector matching.

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

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

Three sentences, each earning its place: the first defines the tool and return format, the second establishes its role, and the third explains the matching behavior. Purpose is front-loaded and 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?

With no output schema, the description compensates by listing the returned fields and the core matching behavior. It covers the tool's primary use, key return semantics, and the exact-match special case. It does not describe shape of results or enumeration behavior, but these are reasonably standard for an element-query 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 input schema already documents all six parameters at 100% coverage. The description's note about text= matching and exact matches is useful but largely restates what the schema's selector and exact fields already say, adding no new parameter-level meaning. Baseline 3 is appropriate.

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

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

Begins with a specific verb and resource: 'Find elements and return structured details,' and lists the exact fields returned (text, value, href, visibility, disabled state, attributes). It also positions itself as 'the main way to see what is on a page before acting on it,' which gives it a distinct role among read-oriented siblings like get_html and get_page_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?

Gives clear context for when to use the tool: it is the primary way to inspect a page before taking action. It does not explicitly name alternatives or provide exclusions, but 'main way' signals preferred usage over sibling tools. Missing explicit when-not-to-use keeps it from a 5.

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?

Since annotations are present, the description goes well beyond them by revealing the tool verifies the document was replaced, returns from/to/tab, and fails with ok false when the old document persists. This gives the agent insight into slow-server and unload-handler behavior without contradicting the readOnly=false, destructive=false, idempotent=true, openWorld=true annotations.

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

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

The description is compact and front-loaded: the core action and verification intent come first, followed by background-tab support, parameter compatibility, return values, and failure semantics. Every sentence adds information without padding.

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

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

Given there is no output schema, the description properly explains what is returned (from, to, tab) and the failure condition (ok false). Combined with the fully documented parameters and annotations, this is enough for an agent to select and call the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents tab_id, timeout_ms, and wait_until_loaded. The description adds little beyond saying these are 'like the other navigating tools,' which is contextually useful but not substantial new parameter meaning.

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

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

The description states a specific action ('Reload a tab') and a resource, then adds the distinct verification purpose: 'confirm the document really was replaced rather than assume it.' This distinguishes reload_tab from siblings like go_back/go_forward/wait_for_load by making its unique behavioral contract explicit.

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 clear usage context by noting it works on a background tab, shares parameters with other navigating tools, and returns from/to/tab. It does not explicitly name alternatives or say 'use this instead of X,' but the verification-focused language and failure semantics make the intended context reasonably clear.

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

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

Annotations already provide idempotentHint and destructiveHint, so the bar is lower. The description adds useful behavioral context by stating that page scrolls report scrollY, pageHeight, and viewport, letting the agent know how much scroll remains. No contradiction with annotations 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?

The description is two sentences with no filler. It front-loads the main purpose and follows with a useful behavioral detail about returned metrics, making every sentence earn its place.

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

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

With six parameters, full schema coverage, and no output schema, the description covers the core page-scroll return value but does not describe the return shape for element scrolls or the verbose output mode. This leaves a minor gap, but overall the definition is sufficiently complete for an agent to call the tool correctly.

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

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

The schema describes all six parameters in full, so the description does not need to explain them. The description adds no parameter-level meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool scrolls the page or scrolls an element into view, with a specific verb and resource. It is unambiguous and readable, but it does not explicitly distinguish it from sibling tools that could also scroll (e.g., press_key or execute_javascript), so it misses 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 guidance about when to use this tool versus alternatives, nor any exclusions or preferred conditions. The description simply describes what it does, leaving the agent to infer when it should be selected over other sibling navigation or input 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?

It discloses a useful behavioral trait beyond the annotations: on a failed match, the error lists existing options so the next call can succeed. Annotations already cover read-only, idempotence, and destructiveness, and the description does not contradict them.

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

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

Two sentences with no filler: the first states the operation and matching semantics, the second adds actionable failure behavior. Every sentence earns its place.

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

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

For a simple select tool with no output schema, the description covers the element type, matching behavior, and failure feedback. It does not describe a successful return value, but the failure behavior is the most decision-relevant outcome for an agent.

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

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

Schema coverage is 100%, so the baseline is 3. The description repeats the matching mode and adds the failure-list behavior, but it does not materially extend the schema's parameter documentation for option, selector, or tab_id.

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

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

The description opens with a specific verb and resource: 'Choose an option in a select element'. It further specifies matching by exact option value or visible label, which clearly distinguishes it from siblings like click, fill, or press_key.

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

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

The description gives clear context by restricting use to select elements, which implies when this tool applies rather than generic click/fill. It does not explicitly name alternatives or exclusion conditions, so it stops short of full routing 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?

Adds useful behavioral context beyond annotations by explicitly stating that the operation changes what the user sees. This complements readOnlyHint=false and gives the agent a strong reason to avoid calling it unnecessarily, even though it does not detail return 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 focused sentences with no waste. The first states the core action and outcome; the second adds important usage guidance. Critical information is front-loaded.

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

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

For a simple two-parameter UI mutation with no output schema, the description covers the core action, user-visible side effect, and a usage caveat. Minor gaps include not naming the exact preferred reading tool and not describing the return value, but these are not significant for correct invocation.

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

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

The input schema already fully documents both parameters, including tab_id's source ('from list_tabs') and activate's default and meaning. The description adds no additional parameter-level meaning, so the schema carries the burden.

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

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

States a specific verb and resource: 'Make a tab the active tab in its window.' It also differentiates from read-only tab operations by noting it changes what the user sees, so an agent can distinguish it from list_tabs, get_current_tab, and content-reading 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?

Provides a clear when-not condition: prefer reading a tab by id when only content is needed. It does not name the exact alternative tool, but the guidance points toward content-reading siblings like get_page_content or get_html rather than switching UI state.

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

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

Annotations already mark this as readOnly, idempotent, and non-destructive. The description adds behavioral detail beyond that: it polls, waits for document readiness, and is meant to follow navigation. It does not mention timeout failure behavior, but that is already covered thoroughly in the timeout_ms parameter description.

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, both essential: the first defines behavior and the second defines when to use it. There is no filler, and the key fact is front-loaded.

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

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

For a simple wait/poll tool with full schema coverage and safety annotations, the description is nearly complete. It could be stronger by contrasting with wait_for_selector, and there is no output schema, but the timeout_ms description already communicates what a call hands back (readyState and url).

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

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

Schema description coverage is 100%, so the baseline is 3. All three parameters already have clear descriptions, defaults, and constraints in the schema. The main description adds no parameter-level meaning beyond what the schema provides.

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

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

The description opens with a specific verb and resource: 'Poll until a tab has finished loading and the document is ready.' This clearly distinguishes it from element-based waiting (wait_for_selector) and navigation-triggering actions (reload_tab, go_back). It is not a tautology of the tool name.

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 second sentence gives explicit placement guidance: 'Use after an action that triggers navigation.' This tells an agent when to invoke the tool. However, it does not explicitly state when not to use it or name alternatives like wait_for_selector, so it stops short of a full 5.

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

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

The description goes well beyond the readOnly/openWorld/idempotent annotations by explaining timeout behavior (waitedMs and last counts), fast-failure on broken selectors/page errors, and the subtle visible-state handling of screen-reader clipping. These are valuable behavioral details an agent needs to interpret results correctly.

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

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

The description is compact and front-loaded, with the purpose stated in the first sentence. Each subsequent sentence adds meaningful behavioral or edge-case information, with no filler or redundant restatement of the title.

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 6 parameters, no output schema, and rich annotations, the description is complete. It covers purpose, when to use it, failure modes, timeout semantics, and a subtle visibility edge case. The schema covers the remaining parameter-level details.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by clarifying what 'visible' means in practice (clipping behavior) and how timeout_ms failure reporting works. This enriches the parameter semantics without repeating schema content.

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

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

The description opens with a precise verb and resource: 'Poll until an element appears, becomes visible, or disappears.' This clearly differentiates it from sibling tools like wait_for_load or query_elements by focusing on selector-based state polling.

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

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

The description gives a clear usage context: 'Use after a click that loads content.' It doesn't explicitly name alternatives or exclusions, but the guidance is specific enough for an agent to know when this polling tool is appropriate.

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