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

With no annotations, the description carries the full behavioral burdenchers. It clearly discloses that the tool sends a request, what each assertion type checks, and that failures are recorded and retrievable via api_errors. It does not cover server-side side effects, auth, or rate limits, but 'Send a request' already signals the side-effecting nature.

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 dense sentences with the primary operation front-loaded before the assertion details. The inline expectFields example is high-value and there is 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 10-parameter tool with no output schema and no annotations, the description is underspecified about the exact report format, how multiple assertions combine, and how to consume api_errors after a failure. It covers the core assertion semantics but leaves several agent-relevant execution details implicit.

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 only 10%, and the description compensates by adding crucial semantics for the three expect_* parameters: exact status code, dot-path equality, and substring matching on raw response text. Request-building parameters like url, body, query, headers, and timeout are not described, but their names and schema types make them reasonably self-explanatory.

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 phrase 'Send a request and assert on it' names a clear verb and object, and the description then lists concrete assertion behaviors: exact status code, dot-path field value matching, and substring matching on raw response text. This distinguishes it from siblings like api_request by making the assertion semantics 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 implies the tool is for request-plus-assertion scenarios, but it never explicitly says when to use it instead of api_request or api_test_suite. There is no when-to-use, when-not-to-use, or alternative-routing guidance, so the agent must infer the intended 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?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It states that the tool clears the error list, but does not mention whether the action is irreversible, whether permissions are required, whether it affects the current session or all recorded errors, or what it returns. This is a significant gap for a mutating operation.

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

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

The description is one short, direct sentence with no filler. It is immediately readable and front-loaded with the verb.

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

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

For a simple no-parameter tool, the description is mostly sufficient, but it omits any detail about the return value or side effects. Since there is no output schema, the agent would not know what to expect after the call. It also lacks usage context, though that is covered in a separate dimension. Overall, it is adequate but with clear gaps.

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

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

The tool has zero parameters, so the description adds all necessary parameter semantics by explaining the tool's purpose. With no input schema properties to document, a baseline of 4 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 ('clear') and a specific resource ('recorded API error list'). It clearly distinguishes itself from sibling tools like browser_clear_errors by explicitly scoping to API errors, and from api_errors which presumably reads errors.

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 or when to avoid it. It does not mention alternatives like api_errors or conditions for clearing. The description only states the action without any context for decision-making.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool lists errors but doesn't disclose whether it clears errors, whether errors persist across calls, how 'recent' is defined, or whether the list is ordered. The description is a simple read operation but lacks behavioral details like retention or ordering.

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

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

The description is a single, concise sentence that front-loads the core purpose and lists error categories efficiently. It earns its place with no wasted words, though it could add a brief note about the limit parameter without becoming verbose.

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

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

For a simple list tool with one optional parameter and no output schema, the description is mostly adequate but incomplete. It fails to explain the 'limit' parameter, the ordering of results, or how this relates to sibling tools like api_clear_errors. An agent would need to guess at the parameter semantics and result format.

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 the undocumented 'limit' parameter. The description does not mention the limit parameter at all, leaving the agent to infer that 'limit' controls the number of errors returned. This is a significant gap for a tool with only one 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 clearly states the tool lists recent API errors and enumerates the error categories (network failures, HTTP 4xx/5xx, failed assertions). It distinguishes itself from sibling tools like browser_errors and api_clear_errors by focusing on API errors rather than browser errors, though it doesn't explicitly name those siblings.

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

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

The description implies usage context: it's for inspecting recent API errors, likely after running API tests or requests. However, it doesn't explicitly state when to use this tool versus alternatives like browser_errors or api_clear_errors, nor does it mention any prerequisites or typical workflow placement.

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

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

With no annotations provided, the description carries the full burden. It discloses the side effect (writing to defaultHeaders), the extraction mechanism (dot path), and the failure mode ('Fails loudly if the token path is not found'). It could also state the default HTTP method or payload serialization, but the most important behaviors are covered.

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 action is stated first, followed by the storage side effect and the error behavior. Every sentence contributes useful information.

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

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

For a tool with no output schema and no annotations, the description covers the main flow, side effects, and a key error condition. Minor gaps remain, such as the default method for the request or how the body is serialized, but these do not prevent correct selection and 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 83%, so the schema already documents most parameters. The description adds value by explaining how tokenPath, headerName, and headerPrefix work together to populate defaultHeaders, and gives a concrete dot-path example. It does not clarify the method parameter, but the core semantics are enhanced 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 sequence of actions: call a login endpoint, extract a token via tokenPath, and store it into defaultHeaders. This clearly distinguishes it from the sibling api_request/api_assert tools by naming its integration effect, so an agent can tell what it 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 clear usage context by stating the token is stored 'for all subsequent api_request/api_assert calls', which implies when the tool should be used. It does not explicitly name alternatives or exclusions, but the purpose is concrete enough to guide selection.

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

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

With no annotations, the description carries the full burden. It discloses the return format (status, headers, body) and the baseUrl resolution behavior. It doesn't mention potential side effects (e.g., POST/DELETE mutations) or error handling, but those are implied by the HTTP method and the tool's nature. It adds meaningful context beyond a bare 'sends an HTTP request' and is not misleading.

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

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

Two concise sentences with zero filler. The primary action and return value are front-loaded, and the usage guidance is added in the second sentence without redundancy. It earns every word.

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, 2 required, no schema descriptions, and no output schema, this description is brief. It covers the essential purpose and usage, but omits parameter semantics, error behavior, and authentication prerequisites. However, given that HTTP semantics are widely understood, it is minimally sufficient for an agent to make a first call, but it leaves room for misunderstanding around query/body/header formats.

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 indirectly explains the 'url' parameter (relative to baseUrl) and does not explain 'body', 'query', 'headers', 'timeout', or 'method' beyond the enum. An agent would have to infer the meaning of these from HTTP conventions, which is not provided here. This is a significant gap given zero schema descriptions.

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

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

The description clearly states the verb ('Send'), the resource ('a single HTTP request to a web API'), and the outcome (returns status, headers and body). It also distinguishes itself from api_assert by naming the alternative explicitly, so an agent can tell them apart without inspecting schemas.

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

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

Provides explicit guidance: 'Use this for one-off exploration; use api_assert when you also want pass/fail checks.' It also clarifies that relative URLs resolve against the baseUrl set by api_set_env, implying a prerequisite without explicitly stating it. This is strong when-to-use vs. when-not-to-use 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?

No annotations are present, so the description carries the burden of exposing side effects. It discloses persistence across subsequent calls and the key merge behavior: 'Merges with existing env unless replace=true.' It could more explicitly state that replace=true discards prior values, but the core behavioral trait is transparent.

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, purposeful sentences: what the tool does, how the environment is merged/replaced, and when to use it. The example is useful and there is 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 configuration tool with no required parameters, no output schema, and no annotations, the description covers the essential invocation context: target fields, persistence, merge behavior, and a typical use case. It could be slightly more explicit about replace=true's exact impact and return behavior, but it is sufficiently complete for correct use.

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 0% schema description coverage and all three parameters undocumented in the schema, the description compensates by explaining baseUrl, defaultHeaders, and especially the replace flag ('Merges with existing env unless replace=true'). It lacks a concrete example for defaultHeaders, but the main parameter meanings are conveyed.

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 base URL and/or default headers used by all subsequent api_request / api_assert / api_test_suite calls.' This clearly separates configuration from the request/assert/suite sibling tools and defines the tool's scope.

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

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

It gives clear context for use ('set baseUrl once at the start of a session') and names the downstream tools it affects. It does not explicitly describe when-not-to-use or name a competing config sibling, but no clear alternative exists among the siblings.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'List' clearly implies a non-mutating read, but the description does not disclose return shape, ordering, whether it only shows locally saved suites, or that it does not run them. This is adequate but has gaps.

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

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

The description is one short, front-loaded sentence with no filler. Every word contributes to identifying the operation and resource.

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

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

For a zero-parameter listing tool, the description is nearly complete: it states the operation and the object. It does not describe the output format or how results connect to api_suite_run, but the implicit 'list' return and absence of parameters make this a minor gap.

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

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

The input schema has zero parameters and the schema description coverage is 100%, so there are no parameter semantics for the description to add. The baseline for a parameterless tool is 4.

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 the specific verb 'List' and names the resource 'saved API test suites', so an agent can tell this is a read-only enumeration operation. It does not explicitly distinguish from siblings like api_suite_run or api_test_suite, but the verb 'list' carries much of that distinction.

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

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

There is no guidance about when to use this tool versus alternatives. It does not mention using it to discover suite IDs before calling api_suite_run, nor does it clarify that listing does not execute the suites. The agent is left without routing information.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Replay', which suggests execution, but it does not state any side effects, whether it is read-only or mutating, what it returns, or any required setup (e.g., authentication). This is a significant gap for a tool that executes tests.

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

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

The description is a single, focused sentence that front-loads the action and resource, and adds the essential prerequisite in parentheses. 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 tool that executes test suites, the description is incomplete. It does not explain what 'replay' entails: whether it runs assertions, returns results, or affects state. There is no output schema, so the description should at least indicate the outcome. The mention of save=true is helpful, but the behavioral outcome is missing, leaving an agent uncertain about what to expect.

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% (the description never names the 'name' field). However, the description's phrase 'by name' implies the purpose of the name parameter (the suite name), adding meaning beyond the schema's generic 'string' type. It does not provide constraints like existence checks or formats, but for a single parameter this is adequate.

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

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

The description uses the specific verb 'Replay' with the resource 'previously saved API test suite' and explicitly ties it to 'api_test_suite with save=true', which distinguishes it clearly from siblings like api_suite_list (list) and api_test_suite (create/save). An agent can immediately understand what this tool does and how it differs.

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 prerequisite: the suite must have been previously saved with save=true, which indicates when this tool is appropriate. It implies you should have a saved suite name in hand. It does not explicitly mention when not to use it or list alternatives, but the condition is stated and the sibling tools provide enough 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 behavioral disclosure burden. It does reveal that cases run in sequence, produce a pass/fail report, and can be persisted with save=true. However, it leaves out HTTP side effects, required environment state, and behavior when an individual case fails.

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 no filler. The primary action, output format, and persistence option are all presented clearly and in order of importance.

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 only three parameters and no output schema, the description covers the essential call pattern, persistence route, and sibling-tool relationship. Minor gaps around the exact report shape and failure semantics keep it from a perfect score, but an agent can understand how to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must provide the parameter meaning. It explains cases as 'same shape as api_assert's inputs' and describes the save/name interaction. It does not clarify whether name is always required or only when saving, and individual case fields are left to 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 opens with a specific action and object: 'Run a list of API test cases' and immediately states the output is an aggregated pass/fail report. It also differentiates from siblings by referencing api_assert's input shape and the save/replay relationship with api_suite_run.

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 it clear this is for executing a batch of cases, while the api_assert reference implies single-assertion alternatives. It explicitly explains the persistence workflow via save=true and name, and points to api_suite_run for replay. It lacks explicit 'when not to use' statements, but the context is sufficient.

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

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

No annotations are provided, so the description carries the full burden. It states the tool is non-mutating (analyze) and lists the return data, but does not disclose potential caveats like whether it waits for page load, truncates large text, or affects console error state. The description is adequate but lacks deeper behavioral detail beyond what is already implied.

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 the core action and returned data front-loaded, followed by a practical usage pointer. Every word contributes value; there is no fluff or repetition. It is an exemplar of concise, structured tool 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?

Given the tool has no parameters and no output schema, the description sufficiently explains what the agent will receive and when to use it. It does not mention potential prerequisites like ensuring the page is loaded, but the sibling set includes browser_wait_human and browser_open, which could be inferred. For a simple analysis tool, the description is largely complete.

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

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

The tool has zero parameters, so the description does not need to explain any. The schema already reflects no inputs, and the description adds no parameter-specific information, which is appropriate. Baseline for 0 params is 4, and the description correctly omits parameter details.

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

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

The description clearly states the tool's action ('Analyze current page') and specifies the structured information returned (title, url, text, inputs, buttons, links, menus, console errors). It explicitly differentiates from the sibling browser_screenshot by advising when to use it instead, making its unique purpose unmistakable.

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

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

The description provides explicit guidance: 'Use this instead of screenshot when you only need to understand the page.' This directly addresses the most likely alternative. However, it does not mention other overlapping tools like browser_text or browser_elements, though the listed return fields implicitly suggest coverage. The guidance is clear for the primary alternative but not exhaustive.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions saving screenshots/errors, but does not disclose critical behaviors such as whether execution stops on the first error, whether a browser must already be open, how results are returned, or what happens on failure. This is a significant gap for a multi-step automation tool.

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

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

The description is concise and front-loaded with the primary purpose, followed by a key usage detail and an alternative. Two sentences with no fluff or redundancy, achieving efficiency.

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

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

Given the complexity of the steps array with multiple actions and properties, and no output schema or annotations, the description is far too brief. It lacks explanations of each action, error handling, prerequisites, and return format, making it 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%, so the description must compensate. It adds semantics for click/fill steps (ref/selector/placeholder) but leaves the other actions (open, press, scroll, wait, screenshot) and properties (url, name, value) unexplained. An agent cannot correctly construct all step types from this description alone.

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

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

The description clearly states the tool runs browser test steps and saves screenshots/errors, giving a specific verb and resource. It also hints at differentiation by mentioning that click/fill steps accept ref/selector/placeholder, and points to flow tools for repeated flows, distinguishing from some 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?

It provides an explicit alternative for repeated flows ('For repeated flows prefer browser_flow_record/browser_flow_run'), which is a clear when-not scenario. However, it does not explicitly state when to use this tool versus the individual browser_click/browser_fill tools, leaving some ambiguity about the intended use case.

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

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

With no annotations, the description carries the full burden. 'Clear' implies a destructive action that is likely irreversible, which is apparent. However, it does not disclose whether clearing affects all tabs, persists across sessions, or has any other side effects. The behavior is minimally described but not contradictory.

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 redundant words. It efficiently communicates the operation without any filler.

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

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

For a no-parameter clear operation with no output schema, the description is adequate. It states exactly what it does. While it could clarify scope (e.g., 'all browser errors'), the context of sibling tools makes it clear enough. Minor ambiguity about persistence or cross-tab effects, but overall sufficient.

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

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

The tool has zero parameters, so the schema coverage is effectively 100%. The description adds no parameter details, which is unnecessary. Baseline for 0 parameters is 4, and the description does not need to elaborate.

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

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

The description clearly states the action (Clear) and the resource (collected browser errors), distinguishing it from sibling tools like api_clear_errors. It does not explicitly name alternatives, but the 'browser' qualifier makes the scope unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives like browser_errors (to inspect) or api_clear_errors. No mention of prerequisites, side effects, or typical workflows. The description simply states the operation without 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?

The description discloses that the tool returns what changed after the click, which is useful behavioral context. However, with no annotations provided, it doesn't disclose potential side effects like navigation, page reloads, or whether the click is awaited. The return behavior is mentioned but not detailed.

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 wasted words. The priority order is front-loaded and the return behavior is stated succinctly. 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 click tool with three optional parameters and no output schema, the description covers the essential targeting logic and return behavior. However, it lacks details on edge cases like what happens if multiple elements match, whether the click waits for navigation, or how errors are surfaced. Given the tool's simplicity, this is adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the priority order of the three parameters (ref, selector, text), which adds meaning beyond the bare schema. However, it doesn't describe the format or semantics of each parameter (e.g., what a 'ref' looks like, how 'text' matching works), leaving 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 states a specific verb and resource ('Click element') and provides a clear priority order for identifying the target (ref, then selector, then text). It distinguishes itself from sibling tools like browser_fill and browser_hover by focusing on clicking, though it doesn't explicitly name those 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 gives explicit guidance on how to choose parameters: prefer 'ref' from browser_elements/browser_mark_screenshot, then 'selector', then 'text'. This is clear usage context, though it doesn't explicitly state when to use this tool versus alternatives like browser_hover or browser_fill.

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

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

No annotations are provided, so the description carries the full burden. It discloses that only visible elements are listed, that each gets a short ref, and that those refs are intended for interaction tools. It does not describe the exact output structure, whether the list is limited to the current viewport, or how refs behave after page changes, leaving some behavioral details implicit.

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 sentence states the operation and scope, and the second adds the ref usage guidance. It 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?

Given zero parameters and no output schema, the description covers the essential contract: visible interactive elements are listed with refs usable by interaction tools. It does not detail output fields or edge cases, but for a simple list tool the provided information is largely sufficient for an agent to invoke and use its results correctly.

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

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

The tool has zero parameters and the schema coverage is effectively complete, so the description does not need to document parameter meanings. It adds relevant semantic context by explaining how the returned refs are used, which goes beyond what the empty 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 uses a specific verb and resource: 'List visible clickable elements and inputs.' It also explains the ref (e1, e2...) mechanism, making the tool's core value clear. It does not explicitly distinguish itself from sibling analysis tools like browser_snapshot or browser_observe, so it stops short of a 5.

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

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

The description gives useful context: this tool returns refs for later browser_click/browser_fill/browser_select/browser_hover calls, and it advises preferring refs over raw selectors/text. However, it does not explain when to choose this tool over sibling tools like browser_observe or browser_snapshot, nor does it mention any exclusions or alternatives.

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

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

No annotations are provided, so the description alone must convey behavior. 'Get' loosely implies a read-only operation, but it does not disclose whether errors are accumulated, whether they persist or are cleared, whether a page must be open, or what format is returned. This is a significant gap for an agent to safely call the tool.

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

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

The description is a single sentence with no superfluous words; it is perfectly concise and front-loaded. Every word earns its place.

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

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

This is a highly minimal description for a simple tool, but it lacks essential contextual information. With no output schema, an agent cannot know what 'errors' are (console errors? network errors?) or what a successful response looks like. It does not explain the relationship to 'browser_clear_errors', nor mention whether errors are scoped to the current page or session. This is a meaningful gap 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 tool has zero parameters, so the description need not add any parameter semantics. Per the rubric, the baseline for 0 parameters is 4, and no additional meaning is required.

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 ('get') and a specific resource ('browser errors'), directly matching the tool name. It distinguishes from the sibling tools 'browser_clear_errors' (get vs clear) and 'api_errors' (browser vs api), making the intent 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 is a bare functional statement with no guidance on when to use it vs. alternatives like 'browser_clear_errors' or 'api_errors'. It does not indicate typical usage scenarios (e.g., after an automation flow) or any preconditions.

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

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

With no annotations, the description carries the burden. It discloses the output format (text/href pairs) and scope (current system navigation), which is useful. However, it doesn't mention whether this is a read-only operation, whether it requires a page to be open, or how it handles dynamic content.

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 wasted words. The core action is front-loaded, and the output format is stated immediately. 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 parameterless tool with no output schema, the description covers the main purpose and output format. However, it lacks context on prerequisites (e.g., must have a page open), whether it works on the current page or entire system, and how it relates to sibling tools like browser_elements. The description is adequate but not complete.

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

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

The tool has zero parameters, so the schema provides no parameter semantics. The description adds value by explaining the output format (text/href pairs) and purpose, which is sufficient for a parameterless tool. Baseline 4 for 0 params 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 extracts navigation menu/link structure and returns text/href pairs, which is a specific verb+resource. It distinguishes itself from siblings like browser_text and browser_elements by focusing on site map building, though it doesn't explicitly name a sibling alternative.

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

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

The description implies usage for building a site map or feature map, which gives context but no explicit when-to-use vs alternatives. It doesn't state when not to use it or mention alternatives like browser_elements or browser_text for link extraction.

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 no annotations are provided, the description carries the full burden of behavioral disclosure. It reveals a locator-preference hierarchy but does not state whether the existing value is replaced, whether focus is needed, or whether input/change events are triggered. 'Fill input' states intent but not side effects.

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

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

The entire description is one front-loaded sentence with no filler. The action and the priority rule are stated directly and efficiently, making every word 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?

For a simple fill action the description is minimally sufficient: an agent knows to provide a value and can choose a locator by priority. But it omits important behavioral context such as clearing existing content, event triggering, and applicability to textareas or contenteditable elements, and there is no output schema to fill that gap.

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

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

Schema coverage is 0%, so the description must compensate. It adds meaning by defining a priority order among ref, selector, and placeholder and ties ref to browser_elements. However, the required 'value' parameter is left completely undefined, and no locator syntax details are provided.

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

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

The description states a clear verb-resource pair ('Fill input') that distinguishes it from sibling browser tools like browser_click, browser_select, and browser_press. It does not explicitly name a competing sibling, but the action 'fill' is unambiguous enough for an agent to identify its core purpose.

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

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

No guidance is given on when to choose browser_fill over alternatives such as browser_press or browser_select. The only usage hint is the parameter-preference order (ref > selector > placeholder), which is about how to invoke the tool rather than when to use it versus siblings.

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 restates the basic function and does not mention return format, ordering, whether an empty list is possible, or any side effects, leaving the agent without useful behavioral context.

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

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

The description is a single, front-loaded sentence with no wasted words. For a zero-parameter tool, this is appropriately sized and structurally efficient.

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

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

The tool is simple with no parameters, so the description covers invocation needs adequately. However, with no output schema and no annotations, it does not explain what the returned list contains or how it is structured, leaving a minor but real completeness gap.

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

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

The tool has zero parameters and the schema coverage is 100%, so there is no parameter documentation burden for the description to carry. The baseline of 4 applies because no parameter semantics are needed.

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

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

The description states a specific verb ('List') and a specific resource ('recorded flows'), making the tool's function immediately clear. It is naturally distinguished from sibling tools like browser_flow_record and browser_flow_run, which perform different actions on flows.

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

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

The description implies usage: use this tool when you need to enumerate recorded flows. However, it provides no explicit guidance about when to prefer this over alternatives or any exclusions, so the usage context is only implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses that recording captures specific actions (open/click/fill/press/scroll) with selectors and that mode=stop saves to disk, but it does not mention potential overwrite behavior, prerequisites (like an active browser session), or error cases.

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, front-loaded with purpose, then mode details. No wasted words, and all information is relevant and ordered logically.

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 only two parameters and no output schema, the description covers the essential usage and mode behavior. It does not explain return values or edge cases, but these are not critical given the simplicity and the presence of sibling tools for context.

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

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

With 0% schema description coverage, the description must compensate. It explicitly explains the 'mode' parameter (start/stop and their effects) and implies 'name' is the flow identifier. This is sufficient for an agent to understand both parameters, though it could be more explicit about name constraints.

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 ('Record') and a resource ('browser actions into a named reusable flow'). It also distinguishes itself from its sibling 'browser_flow_run' by explicitly mentioning replay, making the tool's role clear.

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 provides clear guidance on when to use mode=start vs mode=stop, and mentions the sibling tool for replay. However, it does not explicitly state when not to use this tool or alternative recording methods, so it falls 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. 'Replay' conveys the core behavior of re-executing a recorded flow, but it does not mention side effects such as browser navigation or clicks, nor runtime/failure behavior. This is adequate but thin.

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

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

One concise, front-loaded sentence with no redundant wording. Every part adds value: the action, the object, the selection criterion, and the source tool.

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

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

For a one-parameter tool, the description gives enough to invoke it. However, with no output schema and no annotations, it leaves gaps around how to confirm a flow name is valid and what the result of a successful run looks like.

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 provides only a required string 'name' with no description, so schema description coverage is 0%. The description compensates by specifying that the name is the name of a recorded flow from browser_flow_record, giving the parameter practical 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 verb ('Replay'), a specific resource ('recorded flow'), and qualifies it 'by name' with a pointer to browser_flow_record. This clearly differentiates the tool from sibling browsing and recording tools.

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

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

The phrase 'from browser_flow_record' implies a flow must have been recorded first, which gives basic usage context. However, it does not explicitly state when to use this over alternatives, nor does it mention that browser_flow_list can be used to discover valid flow names.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the destructive action ('Delete') but does not mention permanence, failure behavior for nonexistent names, side effects, or permissions. This is minimal disclosure for a delete operation.

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

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

The description is a single sentence, front-loaded with the action and object. There is no wasted wording or redundant elaboration, making it highly efficient.

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

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

The tool is simple with one known parameter, and the core purpose is clear. However, the lack of annotations, behavioral details, and any mention of what happens on success or failure leaves the description minimally viable but not complete for an agent needing robust expectations.

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

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

The input schema has a single 'name' parameter with no description coverage, and the description does not explicitly explain what 'name' refers to. The phrase 'saved page element memory' offers implicit context that 'name' is the identifier of such a memory, but the description adds little beyond the schema field name.

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 'Delete a saved page element memory' uses a specific verb and resource, clearly distinguishing it from siblings like browser_remember (save) and browser_recall (recall). It is unambiguous about what the tool does.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. It is only a bare statement of action, leaving the agent to infer the appropriate context for deletion.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It doesn't mention side effects like whether the hover implies a click, how it interacts with the page state, or whether it waits for menus to appear. The description is minimal and doesn't disclose any potential side effects.

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

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

The description is a single concise sentence that conveys the core action. It is front-loaded with the action and target. It could be longer, but the brevity is acceptable given the simplicity, though it misses opportunity to add value.

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 three parameters with no descriptions, and no output schema, the description is insufficient. It doesn't explain how the element is identified, whether it returns any confirmation, or what errors might occur. The tool's purpose is simple, but the lack of parameter guidance makes it incomplete.

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

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

Schema description coverage is 0%, and the description does not elaborate on any of the three parameters (ref, text, selector). It doesn't explain how to specify the element, or whether all are needed. The schema itself has no property descriptions, leaving the agent entirely in the dark about parameter semantics.

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

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

The description states the verb 'hover' and resource 'element', and the purpose of triggering hover menus, which is somewhat specific. However, it doesn't distinguish it from sibling tools like browser_click or browser_observe, and the phrase 'hover menus' could be ambiguous.

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 no explicit guidance on when to use this tool versus others. The fact that it triggers hover menus implies a use case, but the description doesn't state when hover is needed or when clicking might be more appropriate.

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

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

With no annotations, the description carries the behavioral burden and does well: it discloses that numbered boxes are drawn, that an image plus selector mapping is returned, and that refs feed into browser_click. It does not discuss limitations like full-page vs viewport capture, but the behavior is clearly conveyed.

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

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

Two tight sentences with no filler. The purpose is front-loaded and the next-step instruction is included 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?

For a parameterless tool with no output schema, the description fully covers what the agent needs: what is produced, what is returned, and how to proceed next. Nothing essential 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 tool has zero parameters and the schema already documents that there are no parameters, so there is nothing for the description to add. This matches the baseline for parameterless tools.

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: screenshots the viewport with numbered boxes over interactive elements, which is Set-of-Mark. This clearly distinguishes it from plain screenshot siblings like browser_screenshot and ties it to the interactive workflow.

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

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

Explicitly instructs the follow-up action: use browser_click with the returned ref, e.g. e3. It implies when to use this tool (when a clickable element map is needed), but does not explicitly mention alternatives or when NOT to use it, such as when a plain screenshot suffices.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'list,' which implies a read-only operation, but it does not mention any side effects, permissions, or the format of the output. For a listing tool, this is minimal but lacks details like whether it returns a snapshot, count, or detailed object.

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

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

The description is a single, concise sentence with no wasted words. It is front-loaded with the core action and resource. While extremely brief, it is appropriately sized for a zero-parameter tool, though it could add a bit more detail without becoming verbose.

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

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

For a zero-parameter tool, the description is arguably sufficient to understand the basic purpose. However, there is no output schema and no explanation of what 'page element memories' are, how they are structured, or whether the list is paginated. Given the rich set of sibling tools, more context about the return format or typical usage would improve completeness.

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

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

The tool has zero parameters and the schema coverage is 100% (empty properties object). Per the rubric, a baseline of 4 applies for zero parameters since there is nothing to document. The description doesn't need to add parameter semantics, but it also doesn't clarify what 'memories' means, which is a minor 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?

The description clearly states the verb 'list' and the resource 'saved page element memories,' which distinguishes it from sibling memory tools like browser_remember (save), browser_recall (retrieve), and browser_forget (delete). However, it doesn't explicitly contrast with browser_recall, which could also be a retrieval operation, leaving slight ambiguity about what 'page element memories' specifically are.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of when listing is appropriate, when to use browser_recall instead, or any prerequisites. The agent must infer usage from the name and description alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Open a new tab' but does not disclose whether the new tab becomes active or focused, whether it returns a tab identifier, or what happens if the URL is invalid. These are significant behavioral aspects for a browser automation tool, and their absence leaves the agent guessing.

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

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

The description is a single, efficient sentence with no filler. The core action is front-loaded, and the optional parameter is mentioned succinctly. It earns its place 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?

The tool is simple with one optional parameter and no output schema, so the description might seem adequate. However, it omits critical context about tab focus/activation, which is directly relevant given the sibling browser_switch_tab tool. The lack of any behavioral disclosure beyond the bare action leaves the agent uncertain about the tool's side effects, making the description incomplete for safe and 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 schema has one parameter (url) with no description, and schema description coverage is 0%. The tool description says 'optionally with a URL,' which clarifies that the url parameter is optional and indicates its purpose. This adds some meaning beyond the raw schema, but it does not elaborate on URL format, default behavior when omitted, or interaction with existing 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?

The description uses a specific verb ('Open') and resource ('a new tab'), clearly indicating the tool's core action. It also mentions the optional URL parameter, which adds specificity. However, it does not explicitly differentiate from sibling tools like browser_open or browser_switch_tab, though the name itself implies a distinct action.

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

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

There is no guidance on when to use this tool versus alternatives such as browser_open (which might open a URL in the current tab) or browser_switch_tab. The description does not state any prerequisites, exclusions, or scenarios where this tool is preferred. It leaves the agent to infer usage from the name alone.

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

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

With no annotations, the description carries the full burden. It discloses the behavioral output of each level (status, elements, screenshot), but does not explicitly state that observation is non-destructive. However, the term 'observation' and the nature of the levels strongly imply read-only behavior, so it is adequately transparent.

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—two sentences—and front-loads the core principle ('use the cheapest level that suffices') before listing options. Every sentence adds value 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?

For a single-parameter tool with no output schema, the description is complete. It covers what each level returns, how to choose, and how it relates to siblings. No essential information is missing for correct invocation.

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

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

The schema only defines 'level' as a number with no description (0% coverage). The description compensates fully by explaining the meaning of levels 0, 1, and 2, including token counts and equivalences. This gives the agent complete information to select the correct value.

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 it is a 'layered observation' tool and explains each level's purpose, explicitly referencing sibling tools (browser_elements, browser_mark_screenshot) to differentiate. This distinguishes it from the many other browser tools.

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

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

It explicitly instructs to 'use the cheapest level that suffices' and describes what each level provides, giving direct guidance on when to choose which level. It also names the sibling tools that match higher levels, making selection unambiguous.

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. 'Open website' implies a navigation action but does not state whether the current tab is replaced, whether a new tab is opened, whether it waits for page load, or what happens on invalid URLs. This is a minimal behavioral statement with no added transparency.

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

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

At two words, the description is extremely concise but not appropriately sized for the information it needs to convey. It lacks structural detail such as a sentence explaining behavior or usage. The brevity reads as under-specification rather than effective 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?

For a tool with one parameter, no annotations, and no output schema, the description is incomplete. It does not explain the effect on the browser session, relationship to sibling browser tools, or error behavior. A simple but functional description would need at least a sentence about navigation semantics.

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 the undocumented 'url' parameter. 'Open website' adds no meaningful semantics beyond the parameter name itself; it does not clarify URL format, required protocol, or how the URL is interpreted. The description fails to compensate for the schema 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?

The description states a specific verb ('Open') and resource ('website'), making the core action clear. However, it does not differentiate from siblings like browser_new_tab or browser_switch_tab, which also relate to opening or navigating to pages. It is clear but lacks the distinctions that would earn a 5.

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

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

The description gives no guidance on when to use browser_open versus alternatives such as browser_new_tab or browser_switch_tab. There is no context about expected workflows, prerequisites, or conditions for selection. The agent must infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses the primary behavior—pressing a key—and hints at real-world effects like form submission, but it does not mention focus requirements, whether the tool waits for resulting page changes, or exact modifier notation beyond an example. This is adequate but not rich.

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

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

The description is two short sentences with no filler: the action verb and examples come first, followed by a targeted use-case sentence. Every word contributes to helping an agent decide when and how to call the tool.

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

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

For a simple one-parameter tool with no output schema and no annotations, the description is largely complete: it states what happens, gives parameter examples, and provides practical use cases. It could mention focus prerequisites or return behavior, but nothing critical is missing for basic invocation.

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

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

The input schema provides only a bare string type with no description, so the tool description must compensate. It adds meaningful value by listing concrete values like Enter, Escape, Tab, ArrowDown, and Control+a, helping an agent construct a valid key argument. It does not enumerate all possible keys, but the examples strongly imply the expected format.

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 ('Press a keyboard key'), gives concrete examples, and clearly differentiates this keyboard action from sibling mouse-oriented tools like browser_click. The inclusion of modifiers such as Control+a further pins down exactly what the tool does.

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

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

The phrase 'Useful for submitting forms or closing dialogs' provides clear context for when an agent should use this tool. It does not explicitly name alternatives or state when not to use it, but the guidance is sufficient for a simple one-parameter action.

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

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

No annotations are provided, so the description carries the full burden. It discloses a key behavioral trait: it skips re-observation and returns a mapping plus stale-selector info. However, it doesn't disclose side effects (e.g., whether it mutates stored state, whether refs are registered globally, or whether it requires a prior browser_remember call). The description adds some behavioral context but leaves important gaps.

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

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

The description is a single, information-dense sentence that front-loads the core action and outcome. It earns its place by explaining the return value and the skipping behavior. Slightly more structure (e.g., separating the return description) could improve readability, but it's appropriately concise.

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

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

For a tool with one parameter and no output schema, the description covers the main purpose and return value. However, it lacks prerequisites (e.g., must call browser_remember first), error conditions (e.g., what if the name doesn't exist), and side-effect details. Given the tool's moderate complexity and zero annotations, the description is adequate but not complete.

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

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

Schema description coverage is 0%, and the description does not explain the 'name' parameter beyond implying it is the saved map's name. With only one parameter, the burden is lower, but the description still doesn't explicitly state what 'name' refers to (e.g., the name used in browser_remember). This is a meaningful gap for an agent trying to call the tool correctly.

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

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

The description clearly states the verb ('Load'), the resource ('saved page element map'), and the key behavior ('register fresh refs... skipping re-observation'). It also names its companion tool browser_remember, which helps distinguish it from siblings. However, it doesn't explicitly contrast with other browser tools like browser_observe or browser_elements, so it's clear but not fully differentiated.

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

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

The description implies when to use it: after browser_remember, when you want to reuse a saved element map without re-observing. It also implicitly contrasts with browser_observe (skipping re-observation). However, it doesn't state explicit when-not-to-use conditions or alternatives beyond the implicit reference to browser_remember.

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 behavioral burden. It adds meaningful detail: refs are resolved to durable selectors with backups before saving and survive page reloads. It does not mention overwrite behavior or return values, but the persistence guarantee is a valuable disclosed trait.

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 short sentences with the action front-loaded, a concrete JSON example, and a pointer to the sibling recall tool. Every sentence earns its place and there is 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 simple two-parameter save tool with no output schema, the description covers the core mechanics, durability, and the recall path. It lacks notes on overwrite behavior or return values, but the included example and explicit persistence detail make the tool sufficiently documented for an agent to invoke it correctly.

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

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

The schema only provides types, and schema description coverage is 0%, so the description must compensate. It explains that name is a semantic page name and refs is a mapping of symbolic names to selectors, reinforced by the loginPage example. This is solid parameter guidance, though it stops short of edge-case constraints like uniqueness or accepted selector formats.

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

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

The description names a specific action (save current refs), a resource (refs under a semantic page name), and the purpose (later reuse). It also references the recall sibling tool, helping an agent distinguish it from browser_recall, browser_forget, and browser_memory_list.

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: use this when current refs should be stored for reuse later, and it explicitly points to browser_recall for retrieval. It does not enumerate when-not-to-use cases or alternative storage tools, but the intended usage is unambiguous.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It states JPEG format, 10s timeout, and fallback, but does not mention side effects, return values, or what happens on failure. It doesn't clarify if the screenshot is saved to disk or returned, nor the behavior of the fallback. This is minimal disclosure for a tool with no 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 concise sentence, which is structurally sound and front-loaded with the core action. However, it is so brief that it omits essential information about parameters and behavior, making it under-specified rather than efficiently concise. The sentence earns its place but doesn't add enough value.

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 2 parameters, no annotations, and no output schema, the description is incomplete. It does not explain the parameters, the return value, or the fallback mechanism. An agent would struggle to call this correctly without additional documentation. The minimal information about JPEG and timeout is helpful but insufficient.

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 no descriptions (0% coverage) and the tool description does not explain the parameters 'name' or 'fullPage'. The description mentions 'viewport screenshot' but does not clarify the purpose of 'name' (likely a filename) or 'fullPage' (likely to capture full page vs viewport). Since the description provides no parameter semantics, it fails to compensate for the lack of schema documentation.

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

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

The description clearly states the verb 'Save' and the resource 'viewport screenshot', with context 'in current project' and additional details like JPEG format, timeout, and fallback. It distinguishes itself from most siblings, though browser_mark_screenshot might be a close alternative, but the description is specific enough.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It mentions 'with fallback' but doesn't explain what that means or when to use it. There is no mention of exclusions or preferred scenarios, leaving the agent to infer the intended usage.

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

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

No annotations are provided, so the description carries the full burden. It says 'scroll the page' but does not disclose how scrolling works: whether it scrolls by a fixed amount, whether it scrolls to the top/bottom, what the optional 'amount' parameter does, or whether it waits for lazy content to load. The mention of 'load lazy content' hints at a side effect but doesn't specify behavior. This is a significant gap for a tool with no other behavioral documentation.

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, focused sentence that gets straight to the point with no filler. The purpose is stated first, and every word contributes to understanding the tool's function.

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 only two parameters, no output schema, and no annotations, the description is insufficiently complete. It does not explain the effect of omitting 'amount', the meaning of direction relative to the page, or any limits (e.g., maximum scroll distance). An agent cannot confidently call this tool correctly without additional assumptions.

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

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

The input schema has 0% description coverage, and the description does not mention either parameter ('direction' or 'amount'). The agent is left to infer the meaning of 'amount' and how direction interacts with scrolling. This is a complete absence of parameter guidance beyond the raw schema 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 clearly states the verb 'scroll' and the resource 'page', and gives a specific purpose ('to load lazy content'). It is distinct from all sibling tools, none of which mention scrolling, so there is no ambiguity about what this tool does.

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

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

The description implies when to use it (when lazy content needs loading) but does not explicitly contrast it with alternatives or state when not to use it. For a simple scroll action this is acceptable, but there is no guidance on edge cases like scrolling within a specific container or handling dynamic content beyond the stated purpose.

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 behavioral disclosure burden. It does disclose how options are matched (by value or visible label), which is useful. However, it does not mention side effects, event triggering, failure behavior when no option matches, or whether the dropdown must be visible first.

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

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

The description is a single, tightly written sentence with no filler. The action and target are front-loaded, and every word adds meaning.

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

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

For a tool with no annotations, no output schema, and 0% schema coverage, the description is too thin. It does not clarify how 'ref' and 'selector' relate to the target dropdown, whether the dropdown is located through a default active element, or how the 'value' parameter should be formatted when matching by label versus value.

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 partially explains the 'value' parameter by saying options can be selected by value or visible label, but it gives no meaning for 'ref' or 'selector', leaving the agent to guess how to target the specific dropdown.

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 ('Select'), a precise resource ('an option in a <select> dropdown'), and the method ('by value or visible label'). It clearly distinguishes itself from sibling tools like browser_click and browser_fill by naming the exact element type and action.

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

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

The intended use case is implied: use this when you need to choose an option in a dropdown. However, it does not explicitly state when NOT to use it or mention alternatives such as browser_fill or browser_click, so guidance on tool selection is left 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 burden of behavioral disclosure. It only states the action (setting viewport size) without mentioning side effects, persistence, effect on current page, or any caveats. The recommendation of 1440x900 is a hint but not a behavioral trait.

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

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

The description is extremely concise, with a single action statement and a practical recommendation. It is front-loaded and contains no unnecessary words, making it easy to scan and quickly understand.

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 setter tool, the description is minimally adequate. It does not describe return values (no output schema), side effects, or how the change affects the browser session. Given the lack of annotations, more context about persistence or reload behavior would be helpful, but the tool's simplicity keeps this at a moderate score.

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

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

Schema coverage is 0%, so the description must compensate for parameter meaning. It does not explain what width and height represent, their units, acceptable ranges, or how they interact. The phrase 'viewport size' implies the parameters correspond to dimensions, but the description adds no detail beyond the schema's property 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 action and resource: 'Set browser viewport size.' It is unambiguous and clearly distinct from sibling tools like browser_click or browser_open. No ambiguity remains about what the tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or contexts where a different tool might be preferable. The only extra note is a recommended size, which is not usage 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?

Annotations are absent, so the description carries the full burden of behavioral disclosure. It does not mention whether the tool is read-only, whether a page must be open, what happens on failure, or if it returns a structured snapshot. The phrase 'Get page structure' implies no side effects but does not confirm 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?

A single sentence with no redundant words. The verb and resource are front-loaded, and the parenthetical examples clarify the scope without adding bulk. It is maximally concise for the 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?

The tool is simple (no params) but has many siblings. The description lists a few element types but does not specify whether it returns a full snapshot object, whether it includes other elements, or how it differs from similar tools like browser_text or browser_observe. Since there is no output schema, the description is the sole guide and is only partially sufficient.

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

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

The tool has zero parameters, so the description need not explain any parameter semantics. The schema is empty and trivially fully covered, so a baseline score of 4 is appropriate; the description adds no parameter-specific value but does not need to.

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

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

The description clearly states the verb 'Get' and the resource 'page structure', listing specific elements (title/url/button texts/inputs). This distinguishes it from siblings like browser_text (which likely extracts text content) and browser_elements (which may list all elements), though it could be more explicit about the output format.

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

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

No guidance is provided on when to use this tool versus the many browser_* siblings (e.g., browser_text, browser_elements, browser_observe). With such a large sibling set, the absence of any selection criteria leaves the agent to guess when a snapshot 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?

No annotations are provided, so the description carries the full burden. It clearly states the core state-changing behavior—switching the active tab—but does not mention how invalid indexes are handled or whether the switch triggers any navigation or waiting behavior. This is acceptable for such a simple operation, but not richly transparent.

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

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

The description is a single short sentence with no filler. Every word contributes meaning, and the important 'from browser_tabs' qualifier is included inline without bloating the 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?

This is a low-complexity tool with one required parameter and no output schema. The description tells the agent what action to perform and where to obtain the index. It could additionally mention index bounds or the result of an invalid index, but the definition is nearly complete for safe 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 only defines 'index' as a number with no description. The text adds meaning by specifying that the index comes from browser_tabs, which tells the agent where to source the value and that it represents a tab's position in that list. It does not state whether the index is zero-based or bounded, but the source hint is valuable.

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 ('Switch') with a clear resource ('a tab') and the exact selection mechanism ('by index (from browser_tabs)'). This clearly distinguishes it from sibling tools like browser_open and browser_new_tab, which create or load tabs rather than activate an existing one.

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 parenthetical '(from browser_tabs)' implies the correct workflow: list existing tabs, then switch by using one of their indexes. However, it does not explicitly state when not to use this tool, such as 'use browser_new_tab to open a new tab 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?

With no annotations, the description carries the full burden of behavior. 'List all' communicates a non-mutating, read-only operation and the parenthetical enumerates the fields returned. It doesn't describe edge cases like an empty no-tab state or whether the active tab is marked, but for a simple listing tool this is adequate disclosure.

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 compact sentence with the operation front-loaded and the return fields in a clear parenthetical. 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 parameterless listing tool, the description is nearly complete: it names the resource, scope, and return fields. It could explicitly state output shape or mention an empty result, but nothing required to invoke 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 tool has zero parameters, so there is no parameter burden to document. The description's parenthetical adds meaningful detail about what each tab entry contains, exceeding what the empty input 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 uses the specific verb 'List' with resource 'all browser tabs' and names the returned fields (index, title, url, active). This clearly distinguishes it from sibling tools like browser_open, browser_switch_tab, or browser_snapshot that do different things.

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 is given. It doesn't mention that this tool is for inspection only, nor does it contrast with alternatives like browser_switch_tab for navigation or browser_snapshot for page content. The context is implied by the name, but there are no explicit exclusions or alternative conditions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Get page text' without specifying whether it returns visible text, full HTML text, or which elements are included. It also does not mention any read-only nature or potential side effects (though likely none). This leaves ambiguity about the exact behavior and return format.

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

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

The description is extremely concise at two words, which is appropriate for such a simple tool. It front-loads the action and resource. However, it could be slightly more informative without losing conciseness, such as adding 'of the current page' to clarify scope. Still, it earns a high score for efficiency.

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

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

Given the simplicity (no parameters, no output schema), the description covers the core function. However, it lacks differentiation from sibling tools and does not clarify what 'text' encompasses or the format of the return. An agent could feasibly invoke it correctly, but might be uncertain about expected output. It is adequate but not fully complete in the context of a rich toolset.

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

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

The tool has zero parameters and the schema is empty (100% coverage). Baseline for 0 params is 4. The description does not need to add parameter semantics because there are none, and the schema already fully documents the lack of parameters. No additional meaning is required.

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 ('Get page text') that clearly communicates the tool's core function. However, it does not distinguish itself from sibling tools like browser_snapshot, browser_observe, or browser_analyze_page, which could also return page text or similar content. Without additional context, an agent might not know which tool to choose among these.

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

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

No guidance is provided on when to use this tool versus alternatives. There are no conditions, exclusions, or examples that help an agent decide between browser_text and other browser read tools. The description simply states what it does without any usage 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. It discloses that the tool polls until the widget disappears or a timeout occurs, and it gives the default timeout duration (120s). This is strong behavioral disclosure for a wait-type operation, though it does not state what happens after timeout occurs.

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 core purpose, then covers behavior, default timeout, and a critical user-communication requirement. 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 wait tool with no output schema and no annotations, the description covers the essential behavioral contract: what it waits for, how it waits, how long it waits by default, and what the agent must do beforehand. It does not describe timeout return behavior or behavior when no CAPTCHA is present, but those are minor gaps for this tool type.

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

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

The single optional timeout parameter has no schema description, so the description must compensate for 0% coverage. The phrase 'timeout (default 120s)' adds meaningful context by implying the parameter controls the wait duration in seconds and indicating a default. However, it does not explicitly explain that the timeout parameter overrides the default or describe acceptable values.

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 ('Wait') and a specific resource ('CAPTCHA / human-verification widget in the browser'). It clearly distinguishes this tool from the sibling browser tools because none of the siblings are about waiting for human interaction.

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 context in which to use the tool: when a CAPTCHA or human-verification widget must be resolved manually. It also provides an explicit precondition: always tell the user you are waiting before calling. It does not mention exclusions or alternatives, but no direct alternative exists among the listed siblings.

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